1. Registry
  2. Packages
  3. Google Cloud (GCP)
  4. API Docs
  5. gemini
  6. DataAnalyticsDataAgent
Viewing docs for Google Cloud v10.2.0
published on Tuesday, Oct 20, 2026 by Pulumi
gcp logo
Viewing docs for Google Cloud v10.2.0
published on Tuesday, Oct 20, 2026 by Pulumi

    A DataAgent lets users interact with configured data sources by using natural language, as part of the Conversational Analytics API.

    Note: Deleting a DataAgent soft-deletes it. A soft-deleted DataAgent is purged after 30 days (see purgeTime), and its dataAgentId cannot be reused in the same project and location until then. Changing a field that forces replacement (such as kmsKey) while keeping the same dataAgentId therefore fails with an ALREADY_EXISTS error; use a new dataAgentId instead.

    To get more information about DataAgent, see:

    Example Usage

    Gemini Data Analytics Data Agent Basic

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const example = new gcp.gemini.DataAnalyticsDataAgent("example", {
        location: "global",
        dataAgentId: "data-agent",
        displayName: "Example data agent",
        description: "Example Gemini Data Analytics data agent.",
        labels: {
            env: "test",
        },
        dataAnalyticsAgent: {
            stagingContext: {
                systemInstruction: "Answer questions about the sample Shakespeare corpus.",
                datasourceReferences: {
                    bq: {
                        tableReferences: [{
                            projectId: "bigquery-public-data",
                            datasetId: "samples",
                            tableId: "shakespeare",
                        }],
                    },
                },
            },
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    example = gcp.gemini.DataAnalyticsDataAgent("example",
        location="global",
        data_agent_id="data-agent",
        display_name="Example data agent",
        description="Example Gemini Data Analytics data agent.",
        labels={
            "env": "test",
        },
        data_analytics_agent={
            "staging_context": {
                "system_instruction": "Answer questions about the sample Shakespeare corpus.",
                "datasource_references": {
                    "bq": {
                        "table_references": [{
                            "project_id": "bigquery-public-data",
                            "dataset_id": "samples",
                            "table_id": "shakespeare",
                        }],
                    },
                },
            },
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/gemini"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := gemini.NewDataAnalyticsDataAgent(ctx, "example", &gemini.DataAnalyticsDataAgentArgs{
    			Location:    pulumi.String("global"),
    			DataAgentId: pulumi.String("data-agent"),
    			DisplayName: pulumi.String("Example data agent"),
    			Description: pulumi.String("Example Gemini Data Analytics data agent."),
    			Labels: pulumi.StringMap{
    				"env": pulumi.String("test"),
    			},
    			DataAnalyticsAgent: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentArgs{
    				StagingContext: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs{
    					SystemInstruction: pulumi.String("Answer questions about the sample Shakespeare corpus."),
    					DatasourceReferences: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs{
    						Bq: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs{
    							TableReferences: gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArray{
    								&gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs{
    									ProjectId: pulumi.String("bigquery-public-data"),
    									DatasetId: pulumi.String("samples"),
    									TableId:   pulumi.String("shakespeare"),
    								},
    							},
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var example = new Gcp.Gemini.DataAnalyticsDataAgent("example", new()
        {
            Location = "global",
            DataAgentId = "data-agent",
            DisplayName = "Example data agent",
            Description = "Example Gemini Data Analytics data agent.",
            Labels = 
            {
                { "env", "test" },
            },
            DataAnalyticsAgent = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentArgs
            {
                StagingContext = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs
                {
                    SystemInstruction = "Answer questions about the sample Shakespeare corpus.",
                    DatasourceReferences = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs
                    {
                        Bq = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs
                        {
                            TableReferences = new[]
                            {
                                new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs
                                {
                                    ProjectId = "bigquery-public-data",
                                    DatasetId = "samples",
                                    TableId = "shakespeare",
                                },
                            },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.gemini.DataAnalyticsDataAgent;
    import com.pulumi.gcp.gemini.DataAnalyticsDataAgentArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var example = new DataAnalyticsDataAgent("example", DataAnalyticsDataAgentArgs.builder()
                .location("global")
                .dataAgentId("data-agent")
                .displayName("Example data agent")
                .description("Example Gemini Data Analytics data agent.")
                .labels(Map.of("env", "test"))
                .dataAnalyticsAgent(DataAnalyticsDataAgentDataAnalyticsAgentArgs.builder()
                    .stagingContext(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs.builder()
                        .systemInstruction("Answer questions about the sample Shakespeare corpus.")
                        .datasourceReferences(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs.builder()
                            .bq(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs.builder()
                                .tableReferences(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs.builder()
                                    .projectId("bigquery-public-data")
                                    .datasetId("samples")
                                    .tableId("shakespeare")
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      example:
        type: gcp:gemini:DataAnalyticsDataAgent
        properties:
          location: global
          dataAgentId: data-agent
          displayName: Example data agent
          description: Example Gemini Data Analytics data agent.
          labels:
            env: test
          dataAnalyticsAgent:
            stagingContext:
              systemInstruction: Answer questions about the sample Shakespeare corpus.
              datasourceReferences:
                bq:
                  tableReferences:
                    - projectId: bigquery-public-data
                      datasetId: samples
                      tableId: shakespeare
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    resource "gcp_gemini_data_analytics_data_agent" "example" {
      lifecycle {
        create_before_destroy = true
      }
      location      = "global"
      data_agent_id = "data-agent"
      display_name  = "Example data agent"
      description   = "Example Gemini Data Analytics data agent."
      labels = {
        "env" = "test"
      }
      data_analytics_agent = {
        staging_context = {
          system_instruction = "Answer questions about the sample Shakespeare corpus."
          datasource_references = {
            bq = {
              table_references = [{
                project_id = "bigquery-public-data"
                dataset_id = "samples"
                table_id   = "shakespeare"
              }]
            }
          }
        }
      }
    }
    

    Gemini Data Analytics Data Agent Bigquery

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const dataset = new gcp.bigquery.Dataset("dataset", {
        datasetId: "data_agent",
        location: "US",
        deleteContentsOnDestroy: true,
    });
    const table = new gcp.bigquery.Table("table", {
        datasetId: dataset.datasetId,
        tableId: "sales",
        deletionProtection: false,
        schema: JSON.stringify([
            {
                name: "order_id",
                type: "STRING",
                mode: "REQUIRED",
            },
            {
                name: "order_total",
                type: "FLOAT",
                mode: "NULLABLE",
            },
        ]),
    });
    const example = new gcp.gemini.DataAnalyticsDataAgent("example", {
        location: "global",
        dataAgentId: "data-agent-bq",
        displayName: "BigQuery data agent",
        description: "Example Gemini Data Analytics data agent backed by BigQuery.",
        labels: {
            env: "test",
        },
        dataAnalyticsAgent: {
            publishedContext: {
                systemInstruction: "Answer questions about sales orders.",
                datasourceReferences: {
                    bq: {
                        tableReferences: [{
                            projectId: dataset.project,
                            datasetId: dataset.datasetId,
                            tableId: table.tableId,
                        }],
                    },
                },
                options: {
                    analysis: {
                        python: {
                            enabled: true,
                        },
                    },
                    datasource: {
                        bigQueryMaxBilledBytes: 1000000000,
                    },
                },
                exampleQueries: [{
                    naturalLanguageQuestion: "What is the total order value?",
                    sqlQuery: "SELECT SUM(order_total) AS total_order_value FROM sales",
                }],
                glossaryTerms: [{
                    displayName: "Order",
                    description: "A customer purchase transaction.",
                    labels: [
                        "sales",
                        "transaction",
                    ],
                }],
                schemaRelationships: [{
                    leftSchemaPaths: {
                        tableFqn: pulumi.interpolate`${dataset.project}.${dataset.datasetId}.${table.tableId}`,
                        paths: ["order_id"],
                    },
                    rightSchemaPaths: {
                        tableFqn: pulumi.interpolate`${dataset.project}.${dataset.datasetId}.${table.tableId}`,
                        paths: ["order_total"],
                    },
                    sources: ["LLM_SUGGESTED"],
                    confidenceScore: 0.9,
                }],
            },
        },
    }, {
        dependsOn: [table],
    });
    
    import pulumi
    import json
    import pulumi_gcp as gcp
    
    dataset = gcp.bigquery.Dataset("dataset",
        dataset_id="data_agent",
        location="US",
        delete_contents_on_destroy=True)
    table = gcp.bigquery.Table("table",
        dataset_id=dataset.dataset_id,
        table_id="sales",
        deletion_protection=False,
        schema=json.dumps([
            {
                "name": "order_id",
                "type": "STRING",
                "mode": "REQUIRED",
            },
            {
                "name": "order_total",
                "type": "FLOAT",
                "mode": "NULLABLE",
            },
        ]))
    example = gcp.gemini.DataAnalyticsDataAgent("example",
        location="global",
        data_agent_id="data-agent-bq",
        display_name="BigQuery data agent",
        description="Example Gemini Data Analytics data agent backed by BigQuery.",
        labels={
            "env": "test",
        },
        data_analytics_agent={
            "published_context": {
                "system_instruction": "Answer questions about sales orders.",
                "datasource_references": {
                    "bq": {
                        "table_references": [{
                            "project_id": dataset.project,
                            "dataset_id": dataset.dataset_id,
                            "table_id": table.table_id,
                        }],
                    },
                },
                "options": {
                    "analysis": {
                        "python": {
                            "enabled": True,
                        },
                    },
                    "datasource": {
                        "big_query_max_billed_bytes": 1000000000,
                    },
                },
                "example_queries": [{
                    "natural_language_question": "What is the total order value?",
                    "sql_query": "SELECT SUM(order_total) AS total_order_value FROM sales",
                }],
                "glossary_terms": [{
                    "display_name": "Order",
                    "description": "A customer purchase transaction.",
                    "labels": [
                        "sales",
                        "transaction",
                    ],
                }],
                "schema_relationships": [{
                    "left_schema_paths": {
                        "table_fqn": pulumi.Output.all(
                            project=dataset.project,
                            dataset_id=dataset.dataset_id,
                            table_id=table.table_id
    ).apply(lambda resolved_outputs: f"{resolved_outputs['project']}.{resolved_outputs['dataset_id']}.{resolved_outputs['table_id']}")
    ,
                        "paths": ["order_id"],
                    },
                    "right_schema_paths": {
                        "table_fqn": pulumi.Output.all(
                            project=dataset.project,
                            dataset_id=dataset.dataset_id,
                            table_id=table.table_id
    ).apply(lambda resolved_outputs: f"{resolved_outputs['project']}.{resolved_outputs['dataset_id']}.{resolved_outputs['table_id']}")
    ,
                        "paths": ["order_total"],
                    },
                    "sources": ["LLM_SUGGESTED"],
                    "confidence_score": 0.9,
                }],
            },
        },
        opts = pulumi.ResourceOptions(depends_on=[table]))
    
    package main
    
    import (
    	"encoding/json"
    	"fmt"
    
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/bigquery"
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/gemini"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		dataset, err := bigquery.NewDataset(ctx, "dataset", &bigquery.DatasetArgs{
    			DatasetId:               pulumi.String("data_agent"),
    			Location:                pulumi.String("US"),
    			DeleteContentsOnDestroy: pulumi.Bool(true),
    		})
    		if err != nil {
    			return err
    		}
    		tmpJSON0, err := json.Marshal([]interface{}{
    			map[string]string{
    				"name": "order_id",
    				"type": "STRING",
    				"mode": "REQUIRED",
    			},
    			map[string]string{
    				"name": "order_total",
    				"type": "FLOAT",
    				"mode": "NULLABLE",
    			},
    		})
    		if err != nil {
    			return err
    		}
    		json0 := string(tmpJSON0)
    		table, err := bigquery.NewTable(ctx, "table", &bigquery.TableArgs{
    			DatasetId:          dataset.DatasetId,
    			TableId:            pulumi.String("sales"),
    			DeletionProtection: pulumi.Bool(false),
    			Schema:             pulumi.String(json0),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = gemini.NewDataAnalyticsDataAgent(ctx, "example", &gemini.DataAnalyticsDataAgentArgs{
    			Location:    pulumi.String("global"),
    			DataAgentId: pulumi.String("data-agent-bq"),
    			DisplayName: pulumi.String("BigQuery data agent"),
    			Description: pulumi.String("Example Gemini Data Analytics data agent backed by BigQuery."),
    			Labels: pulumi.StringMap{
    				"env": pulumi.String("test"),
    			},
    			DataAnalyticsAgent: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentArgs{
    				PublishedContext: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextArgs{
    					SystemInstruction: pulumi.String("Answer questions about sales orders."),
    					DatasourceReferences: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesArgs{
    						Bq: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqArgs{
    							TableReferences: gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArray{
    								&gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArgs{
    									ProjectId: dataset.Project,
    									DatasetId: dataset.DatasetId,
    									TableId:   table.TableId,
    								},
    							},
    						},
    					},
    					Options: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsArgs{
    						Analysis: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisArgs{
    							Python: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPythonArgs{
    								Enabled: pulumi.Bool(true),
    							},
    						},
    						Datasource: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasourceArgs{
    							BigQueryMaxBilledBytes: pulumi.Int(1000000000),
    						},
    					},
    					ExampleQueries: gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArray{
    						&gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArgs{
    							NaturalLanguageQuestion: pulumi.String("What is the total order value?"),
    							SqlQuery:                pulumi.String("SELECT SUM(order_total) AS total_order_value FROM sales"),
    						},
    					},
    					GlossaryTerms: gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArray{
    						&gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArgs{
    							DisplayName: pulumi.String("Order"),
    							Description: pulumi.String("A customer purchase transaction."),
    							Labels: pulumi.StringArray{
    								pulumi.String("sales"),
    								pulumi.String("transaction"),
    							},
    						},
    					},
    					SchemaRelationships: gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArray{
    						&gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArgs{
    							LeftSchemaPaths: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPathsArgs{
    								TableFqn: pulumi.All(dataset.Project, dataset.DatasetId, table.TableId).ApplyT(func(_args []interface{}) (string, error) {
    									project := _args[0].(string)
    									datasetId := _args[1].(string)
    									tableId := _args[2].(string)
    									return fmt.Sprintf("%v.%v.%v", project, datasetId, tableId), nil
    								}).(pulumi.StringOutput),
    								Paths: pulumi.StringArray{
    									pulumi.String("order_id"),
    								},
    							},
    							RightSchemaPaths: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPathsArgs{
    								TableFqn: pulumi.All(dataset.Project, dataset.DatasetId, table.TableId).ApplyT(func(_args []interface{}) (string, error) {
    									project := _args[0].(string)
    									datasetId := _args[1].(string)
    									tableId := _args[2].(string)
    									return fmt.Sprintf("%v.%v.%v", project, datasetId, tableId), nil
    								}).(pulumi.StringOutput),
    								Paths: pulumi.StringArray{
    									pulumi.String("order_total"),
    								},
    							},
    							Sources: pulumi.StringArray{
    								pulumi.String("LLM_SUGGESTED"),
    							},
    							ConfidenceScore: pulumi.Float64(0.9),
    						},
    					},
    				},
    			},
    		}, pulumi.DependsOn([]pulumi.Resource{
    			table,
    		}))
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using System.Text.Json;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var dataset = new Gcp.BigQuery.Dataset("dataset", new()
        {
            DatasetId = "data_agent",
            Location = "US",
            DeleteContentsOnDestroy = true,
        });
    
        var table = new Gcp.BigQuery.Table("table", new()
        {
            DatasetId = dataset.DatasetId,
            TableId = "sales",
            DeletionProtection = false,
            Schema = JsonSerializer.Serialize(new[]
            {
                new Dictionary<string, object?>
                {
                    ["name"] = "order_id",
                    ["type"] = "STRING",
                    ["mode"] = "REQUIRED",
                },
                new Dictionary<string, object?>
                {
                    ["name"] = "order_total",
                    ["type"] = "FLOAT",
                    ["mode"] = "NULLABLE",
                },
            }),
        });
    
        var example = new Gcp.Gemini.DataAnalyticsDataAgent("example", new()
        {
            Location = "global",
            DataAgentId = "data-agent-bq",
            DisplayName = "BigQuery data agent",
            Description = "Example Gemini Data Analytics data agent backed by BigQuery.",
            Labels = 
            {
                { "env", "test" },
            },
            DataAnalyticsAgent = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentArgs
            {
                PublishedContext = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextArgs
                {
                    SystemInstruction = "Answer questions about sales orders.",
                    DatasourceReferences = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesArgs
                    {
                        Bq = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqArgs
                        {
                            TableReferences = new[]
                            {
                                new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArgs
                                {
                                    ProjectId = dataset.Project,
                                    DatasetId = dataset.DatasetId,
                                    TableId = table.TableId,
                                },
                            },
                        },
                    },
                    Options = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsArgs
                    {
                        Analysis = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisArgs
                        {
                            Python = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPythonArgs
                            {
                                Enabled = true,
                            },
                        },
                        Datasource = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasourceArgs
                        {
                            BigQueryMaxBilledBytes = 1000000000,
                        },
                    },
                    ExampleQueries = new[]
                    {
                        new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArgs
                        {
                            NaturalLanguageQuestion = "What is the total order value?",
                            SqlQuery = "SELECT SUM(order_total) AS total_order_value FROM sales",
                        },
                    },
                    GlossaryTerms = new[]
                    {
                        new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArgs
                        {
                            DisplayName = "Order",
                            Description = "A customer purchase transaction.",
                            Labels = new[]
                            {
                                "sales",
                                "transaction",
                            },
                        },
                    },
                    SchemaRelationships = new[]
                    {
                        new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArgs
                        {
                            LeftSchemaPaths = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPathsArgs
                            {
                                TableFqn = Output.Tuple(dataset.Project, dataset.DatasetId, table.TableId).Apply(values =>
                                {
                                    var project = values.Item1;
                                    var datasetId = values.Item2;
                                    var tableId = values.Item3;
                                    return $"{project}.{datasetId}.{tableId}";
                                }),
                                Paths = new[]
                                {
                                    "order_id",
                                },
                            },
                            RightSchemaPaths = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPathsArgs
                            {
                                TableFqn = Output.Tuple(dataset.Project, dataset.DatasetId, table.TableId).Apply(values =>
                                {
                                    var project = values.Item1;
                                    var datasetId = values.Item2;
                                    var tableId = values.Item3;
                                    return $"{project}.{datasetId}.{tableId}";
                                }),
                                Paths = new[]
                                {
                                    "order_total",
                                },
                            },
                            Sources = new[]
                            {
                                "LLM_SUGGESTED",
                            },
                            ConfidenceScore = 0.9,
                        },
                    },
                },
            },
        }, new CustomResourceOptions
        {
            DependsOn =
            {
                table,
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.bigquery.Dataset;
    import com.pulumi.gcp.bigquery.DatasetArgs;
    import com.pulumi.gcp.bigquery.Table;
    import com.pulumi.gcp.bigquery.TableArgs;
    import com.pulumi.gcp.gemini.DataAnalyticsDataAgent;
    import com.pulumi.gcp.gemini.DataAnalyticsDataAgentArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPythonArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasourceArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPathsArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPathsArgs;
    import static com.pulumi.codegen.internal.Serialization.*;
    import com.pulumi.resources.CustomResourceOptions;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var dataset = new Dataset("dataset", DatasetArgs.builder()
                .datasetId("data_agent")
                .location("US")
                .deleteContentsOnDestroy(true)
                .build());
    
            var table = new Table("table", TableArgs.builder()
                .datasetId(dataset.datasetId())
                .tableId("sales")
                .deletionProtection(false)
                .schema(serializeJson(
                    jsonArray(
                        jsonObject(
                            jsonProperty("name", "order_id"),
                            jsonProperty("type", "STRING"),
                            jsonProperty("mode", "REQUIRED")
                        ), 
                        jsonObject(
                            jsonProperty("name", "order_total"),
                            jsonProperty("type", "FLOAT"),
                            jsonProperty("mode", "NULLABLE")
                        )
                    )))
                .build());
    
            var example = new DataAnalyticsDataAgent("example", DataAnalyticsDataAgentArgs.builder()
                .location("global")
                .dataAgentId("data-agent-bq")
                .displayName("BigQuery data agent")
                .description("Example Gemini Data Analytics data agent backed by BigQuery.")
                .labels(Map.of("env", "test"))
                .dataAnalyticsAgent(DataAnalyticsDataAgentDataAnalyticsAgentArgs.builder()
                    .publishedContext(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextArgs.builder()
                        .systemInstruction("Answer questions about sales orders.")
                        .datasourceReferences(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesArgs.builder()
                            .bq(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqArgs.builder()
                                .tableReferences(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArgs.builder()
                                    .projectId(dataset.project())
                                    .datasetId(dataset.datasetId())
                                    .tableId(table.tableId())
                                    .build())
                                .build())
                            .build())
                        .options(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsArgs.builder()
                            .analysis(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisArgs.builder()
                                .python(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPythonArgs.builder()
                                    .enabled(true)
                                    .build())
                                .build())
                            .datasource(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasourceArgs.builder()
                                .bigQueryMaxBilledBytes(1000000000)
                                .build())
                            .build())
                        .exampleQueries(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArgs.builder()
                            .naturalLanguageQuestion("What is the total order value?")
                            .sqlQuery("SELECT SUM(order_total) AS total_order_value FROM sales")
                            .build())
                        .glossaryTerms(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArgs.builder()
                            .displayName("Order")
                            .description("A customer purchase transaction.")
                            .labels(                        
                                "sales",
                                "transaction")
                            .build())
                        .schemaRelationships(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArgs.builder()
                            .leftSchemaPaths(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPathsArgs.builder()
                                .tableFqn(Output.tuple(dataset.project(), dataset.datasetId(), table.tableId()).applyValue(values -> {
                                    var project = values.t1;
                                    var datasetId = values.t2;
                                    var tableId = values.t3;
                                    return String.format("%s.%s.%s", project,datasetId,tableId);
                                }))
                                .paths("order_id")
                                .build())
                            .rightSchemaPaths(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPathsArgs.builder()
                                .tableFqn(Output.tuple(dataset.project(), dataset.datasetId(), table.tableId()).applyValue(values -> {
                                    var project = values.t1;
                                    var datasetId = values.t2;
                                    var tableId = values.t3;
                                    return String.format("%s.%s.%s", project,datasetId,tableId);
                                }))
                                .paths("order_total")
                                .build())
                            .sources("LLM_SUGGESTED")
                            .confidenceScore(0.9)
                            .build())
                        .build())
                    .build())
                .build(), CustomResourceOptions.builder()
                    .dependsOn(table)
                    .build());
    
        }
    }
    
    resources:
      dataset:
        type: gcp:bigquery:Dataset
        properties:
          datasetId: data_agent
          location: US
          deleteContentsOnDestroy: true
      table:
        type: gcp:bigquery:Table
        properties:
          datasetId: ${dataset.datasetId}
          tableId: sales
          deletionProtection: false
          schema:
            fn::toJSON:
              - name: order_id
                type: STRING
                mode: REQUIRED
              - name: order_total
                type: FLOAT
                mode: NULLABLE
      example:
        type: gcp:gemini:DataAnalyticsDataAgent
        properties:
          location: global
          dataAgentId: data-agent-bq
          displayName: BigQuery data agent
          description: Example Gemini Data Analytics data agent backed by BigQuery.
          labels:
            env: test
          dataAnalyticsAgent:
            publishedContext:
              systemInstruction: Answer questions about sales orders.
              datasourceReferences:
                bq:
                  tableReferences:
                    - projectId: ${dataset.project}
                      datasetId: ${dataset.datasetId}
                      tableId: ${table.tableId}
              options:
                analysis:
                  python:
                    enabled: true
                datasource:
                  bigQueryMaxBilledBytes: 1e+09
              exampleQueries:
                - naturalLanguageQuestion: What is the total order value?
                  sqlQuery: SELECT SUM(order_total) AS total_order_value FROM sales
              glossaryTerms:
                - displayName: Order
                  description: A customer purchase transaction.
                  labels:
                    - sales
                    - transaction
              schemaRelationships:
                - leftSchemaPaths:
                    tableFqn: ${dataset.project}.${dataset.datasetId}.${table.tableId}
                    paths:
                      - order_id
                  rightSchemaPaths:
                    tableFqn: ${dataset.project}.${dataset.datasetId}.${table.tableId}
                    paths:
                      - order_total
                  sources:
                    - LLM_SUGGESTED
                  confidenceScore: 0.9
        options:
          dependsOn:
            - ${table}
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    resource "gcp_bigquery_dataset" "dataset" {
      lifecycle {
        create_before_destroy = true
      }
      dataset_id                 = "data_agent"
      location                   = "US"
      delete_contents_on_destroy = true
    }
    resource "gcp_bigquery_table" "table" {
      lifecycle {
        create_before_destroy = true
      }
      dataset_id          = gcp_bigquery_dataset.dataset.dataset_id
      table_id            = "sales"
      deletion_protection = false
      schema = jsonencode([{
        "name" = "order_id"
        "type" = "STRING"
        "mode" = "REQUIRED"
        }, {
        "name" = "order_total"
        "type" = "FLOAT"
        "mode" = "NULLABLE"
      }])
    }
    resource "gcp_gemini_data_analytics_data_agent" "example" {
      depends_on = [gcp_bigquery_table.table]
      lifecycle {
        create_before_destroy = true
      }
      location      = "global"
      data_agent_id = "data-agent-bq"
      display_name  = "BigQuery data agent"
      description   = "Example Gemini Data Analytics data agent backed by BigQuery."
      labels = {
        "env" = "test"
      }
      data_analytics_agent = {
        published_context = {
          system_instruction = "Answer questions about sales orders."
          datasource_references = {
            bq = {
              table_references = [{
                project_id = gcp_bigquery_dataset.dataset.project
                dataset_id = gcp_bigquery_dataset.dataset.dataset_id
                table_id   = gcp_bigquery_table.table.table_id
              }]
            }
          }
          options = {
            analysis = {
              python = {
                enabled = true
              }
            }
            datasource = {
              big_query_max_billed_bytes = 1000000000
            }
          }
          example_queries = [{
            natural_language_question = "What is the total order value?"
            sql_query                 = "SELECT SUM(order_total) AS total_order_value FROM sales"
          }]
          glossary_terms = [{
            display_name = "Order"
            description  = "A customer purchase transaction."
            labels       = ["sales", "transaction"]
          }]
          schema_relationships = [{
            left_schema_paths = {
              table_fqn ="${gcp_bigquery_dataset.dataset.project}.${gcp_bigquery_dataset.dataset.dataset_id}.${gcp_bigquery_table.table.table_id}"
              paths     = ["order_id"]
            }
            right_schema_paths = {
              table_fqn ="${gcp_bigquery_dataset.dataset.project}.${gcp_bigquery_dataset.dataset.dataset_id}.${gcp_bigquery_table.table.table_id}"
              paths     = ["order_total"]
            }
            sources          = ["LLM_SUGGESTED"]
            confidence_score = 0.9
          }]
        }
      }
    }
    

    Gemini Data Analytics Data Agent Cmek

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const project = gcp.organizations.getProject({});
    const kmsIam = new gcp.kms.CryptoKeyIAMMember("kms_iam", {
        cryptoKeyId: "kms-key",
        role: "roles/cloudkms.cryptoKeyEncrypterDecrypter",
        member: project.then(project => `serviceAccount:service-${project.number}@gcp-sa-geminidataanalytics.iam.gserviceaccount.com`),
    });
    const example = new gcp.gemini.DataAnalyticsDataAgent("example", {
        location: "us-central1",
        dataAgentId: "data-agent-cmek",
        displayName: "CMEK data agent",
        description: "Example Gemini Data Analytics data agent with customer-managed encryption.",
        kmsKey: "kms-key",
        dataAnalyticsAgent: {
            stagingContext: {
                systemInstruction: "Answer questions about the sample Shakespeare corpus.",
                datasourceReferences: {
                    bq: {
                        tableReferences: [{
                            projectId: "bigquery-public-data",
                            datasetId: "samples",
                            tableId: "shakespeare",
                        }],
                    },
                },
            },
        },
    }, {
        dependsOn: [kmsIam],
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    project = gcp.organizations.get_project()
    kms_iam = gcp.kms.CryptoKeyIAMMember("kms_iam",
        crypto_key_id="kms-key",
        role="roles/cloudkms.cryptoKeyEncrypterDecrypter",
        member=f"serviceAccount:service-{project.number}@gcp-sa-geminidataanalytics.iam.gserviceaccount.com")
    example = gcp.gemini.DataAnalyticsDataAgent("example",
        location="us-central1",
        data_agent_id="data-agent-cmek",
        display_name="CMEK data agent",
        description="Example Gemini Data Analytics data agent with customer-managed encryption.",
        kms_key="kms-key",
        data_analytics_agent={
            "staging_context": {
                "system_instruction": "Answer questions about the sample Shakespeare corpus.",
                "datasource_references": {
                    "bq": {
                        "table_references": [{
                            "project_id": "bigquery-public-data",
                            "dataset_id": "samples",
                            "table_id": "shakespeare",
                        }],
                    },
                },
            },
        },
        opts = pulumi.ResourceOptions(depends_on=[kms_iam]))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/gemini"
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/kms"
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/organizations"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		project, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
    		if err != nil {
    			return err
    		}
    		kmsIam, err := kms.NewCryptoKeyIAMMember(ctx, "kms_iam", &kms.CryptoKeyIAMMemberArgs{
    			CryptoKeyId: pulumi.String("kms-key"),
    			Role:        pulumi.String("roles/cloudkms.cryptoKeyEncrypterDecrypter"),
    			Member:      pulumi.Sprintf("serviceAccount:service-%v@gcp-sa-geminidataanalytics.iam.gserviceaccount.com", project.Number),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = gemini.NewDataAnalyticsDataAgent(ctx, "example", &gemini.DataAnalyticsDataAgentArgs{
    			Location:    pulumi.String("us-central1"),
    			DataAgentId: pulumi.String("data-agent-cmek"),
    			DisplayName: pulumi.String("CMEK data agent"),
    			Description: pulumi.String("Example Gemini Data Analytics data agent with customer-managed encryption."),
    			KmsKey:      pulumi.String("kms-key"),
    			DataAnalyticsAgent: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentArgs{
    				StagingContext: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs{
    					SystemInstruction: pulumi.String("Answer questions about the sample Shakespeare corpus."),
    					DatasourceReferences: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs{
    						Bq: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs{
    							TableReferences: gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArray{
    								&gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs{
    									ProjectId: pulumi.String("bigquery-public-data"),
    									DatasetId: pulumi.String("samples"),
    									TableId:   pulumi.String("shakespeare"),
    								},
    							},
    						},
    					},
    				},
    			},
    		}, pulumi.DependsOn([]pulumi.Resource{
    			kmsIam,
    		}))
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var project = Gcp.Organizations.GetProject.Invoke();
    
        var kmsIam = new Gcp.Kms.CryptoKeyIAMMember("kms_iam", new()
        {
            CryptoKeyId = "kms-key",
            Role = "roles/cloudkms.cryptoKeyEncrypterDecrypter",
            Member = $"serviceAccount:service-{project.Apply(getProjectResult => getProjectResult.Number)}@gcp-sa-geminidataanalytics.iam.gserviceaccount.com",
        });
    
        var example = new Gcp.Gemini.DataAnalyticsDataAgent("example", new()
        {
            Location = "us-central1",
            DataAgentId = "data-agent-cmek",
            DisplayName = "CMEK data agent",
            Description = "Example Gemini Data Analytics data agent with customer-managed encryption.",
            KmsKey = "kms-key",
            DataAnalyticsAgent = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentArgs
            {
                StagingContext = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs
                {
                    SystemInstruction = "Answer questions about the sample Shakespeare corpus.",
                    DatasourceReferences = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs
                    {
                        Bq = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs
                        {
                            TableReferences = new[]
                            {
                                new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs
                                {
                                    ProjectId = "bigquery-public-data",
                                    DatasetId = "samples",
                                    TableId = "shakespeare",
                                },
                            },
                        },
                    },
                },
            },
        }, new CustomResourceOptions
        {
            DependsOn =
            {
                kmsIam,
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.organizations.OrganizationsFunctions;
    import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
    import com.pulumi.gcp.kms.CryptoKeyIAMMember;
    import com.pulumi.gcp.kms.CryptoKeyIAMMemberArgs;
    import com.pulumi.gcp.gemini.DataAnalyticsDataAgent;
    import com.pulumi.gcp.gemini.DataAnalyticsDataAgentArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs;
    import com.pulumi.gcp.gemini.inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs;
    import com.pulumi.resources.CustomResourceOptions;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
                .build());
    
            var kmsIam = new CryptoKeyIAMMember("kmsIam", CryptoKeyIAMMemberArgs.builder()
                .cryptoKeyId("kms-key")
                .role("roles/cloudkms.cryptoKeyEncrypterDecrypter")
                .member(String.format("serviceAccount:service-%s@gcp-sa-geminidataanalytics.iam.gserviceaccount.com", project.number()))
                .build());
    
            var example = new DataAnalyticsDataAgent("example", DataAnalyticsDataAgentArgs.builder()
                .location("us-central1")
                .dataAgentId("data-agent-cmek")
                .displayName("CMEK data agent")
                .description("Example Gemini Data Analytics data agent with customer-managed encryption.")
                .kmsKey("kms-key")
                .dataAnalyticsAgent(DataAnalyticsDataAgentDataAnalyticsAgentArgs.builder()
                    .stagingContext(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs.builder()
                        .systemInstruction("Answer questions about the sample Shakespeare corpus.")
                        .datasourceReferences(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs.builder()
                            .bq(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs.builder()
                                .tableReferences(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs.builder()
                                    .projectId("bigquery-public-data")
                                    .datasetId("samples")
                                    .tableId("shakespeare")
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .build(), CustomResourceOptions.builder()
                    .dependsOn(kmsIam)
                    .build());
    
        }
    }
    
    resources:
      kmsIam:
        type: gcp:kms:CryptoKeyIAMMember
        name: kms_iam
        properties:
          cryptoKeyId: kms-key
          role: roles/cloudkms.cryptoKeyEncrypterDecrypter
          member: serviceAccount:service-${project.number}@gcp-sa-geminidataanalytics.iam.gserviceaccount.com
      example:
        type: gcp:gemini:DataAnalyticsDataAgent
        properties:
          location: us-central1
          dataAgentId: data-agent-cmek
          displayName: CMEK data agent
          description: Example Gemini Data Analytics data agent with customer-managed encryption.
          kmsKey: kms-key
          dataAnalyticsAgent:
            stagingContext:
              systemInstruction: Answer questions about the sample Shakespeare corpus.
              datasourceReferences:
                bq:
                  tableReferences:
                    - projectId: bigquery-public-data
                      datasetId: samples
                      tableId: shakespeare
        options:
          dependsOn:
            - ${kmsIam}
    variables:
      project:
        fn::invoke:
          function: gcp:organizations:getProject
          arguments: {}
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    data "gcp_organizations_project" "project" {
    }
    
    resource "gcp_kms_crypto_key_i_a_m_member" "kms_iam" {
      lifecycle {
        create_before_destroy = true
      }
      crypto_key_id = "kms-key"
      role          = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
      member        ="serviceAccount:service-${data.gcp_organizations_project.project.number}@gcp-sa-geminidataanalytics.iam.gserviceaccount.com"
    }
    resource "gcp_gemini_data_analytics_data_agent" "example" {
      depends_on = [gcp_kms_crypto_key_i_a_m_member.kms_iam]
      lifecycle {
        create_before_destroy = true
      }
      location      = "us-central1"
      data_agent_id = "data-agent-cmek"
      display_name  = "CMEK data agent"
      description   = "Example Gemini Data Analytics data agent with customer-managed encryption."
      kms_key       = "kms-key"
      data_analytics_agent = {
        staging_context = {
          system_instruction = "Answer questions about the sample Shakespeare corpus."
          datasource_references = {
            bq = {
              table_references = [{
                project_id = "bigquery-public-data"
                dataset_id = "samples"
                table_id   = "shakespeare"
              }]
            }
          }
        }
      }
    }
    

    Create DataAnalyticsDataAgent Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new DataAnalyticsDataAgent(name: string, args: DataAnalyticsDataAgentArgs, opts?: CustomResourceOptions);
    @overload
    def DataAnalyticsDataAgent(resource_name: str,
                               args: DataAnalyticsDataAgentArgs,
                               opts: Optional[ResourceOptions] = None)
    
    @overload
    def DataAnalyticsDataAgent(resource_name: str,
                               opts: Optional[ResourceOptions] = None,
                               data_agent_id: Optional[str] = None,
                               location: Optional[str] = None,
                               data_analytics_agent: Optional[DataAnalyticsDataAgentDataAnalyticsAgentArgs] = None,
                               deletion_policy: Optional[str] = None,
                               description: Optional[str] = None,
                               display_name: Optional[str] = None,
                               kms_key: Optional[str] = None,
                               labels: Optional[Mapping[str, str]] = None,
                               project: Optional[str] = None)
    func NewDataAnalyticsDataAgent(ctx *Context, name string, args DataAnalyticsDataAgentArgs, opts ...ResourceOption) (*DataAnalyticsDataAgent, error)
    public DataAnalyticsDataAgent(string name, DataAnalyticsDataAgentArgs args, CustomResourceOptions? opts = null)
    public DataAnalyticsDataAgent(String name, DataAnalyticsDataAgentArgs args)
    public DataAnalyticsDataAgent(String name, DataAnalyticsDataAgentArgs args, CustomResourceOptions options)
    
    type: gcp:gemini:DataAnalyticsDataAgent
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    resource "gcp_gemini_data_analytics_data_agent" "name" {
        # resource properties
    }

    Parameters

    name string
    The unique name of the resource.
    args DataAnalyticsDataAgentArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args DataAnalyticsDataAgentArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args DataAnalyticsDataAgentArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args DataAnalyticsDataAgentArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args DataAnalyticsDataAgentArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var dataAnalyticsDataAgentResource = new Gcp.Gemini.DataAnalyticsDataAgent("dataAnalyticsDataAgentResource", new()
    {
        DataAgentId = "string",
        Location = "string",
        DataAnalyticsAgent = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentArgs
        {
            LastPublishedContexts = new[]
            {
                new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextArgs
                {
                    DatasourceReferences = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesArgs
                    {
                        Bq = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqArgs
                        {
                            TableReferences = new[]
                            {
                                new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqTableReferenceArgs
                                {
                                    DatasetId = "string",
                                    ProjectId = "string",
                                    TableId = "string",
                                },
                            },
                        },
                    },
                    SystemInstruction = "string",
                },
            },
            PublishedContext = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextArgs
            {
                DatasourceReferences = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesArgs
                {
                    Bq = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqArgs
                    {
                        TableReferences = new[]
                        {
                            new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArgs
                            {
                                DatasetId = "string",
                                ProjectId = "string",
                                TableId = "string",
                            },
                        },
                    },
                },
                ExampleQueries = new[]
                {
                    new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArgs
                    {
                        NaturalLanguageQuestion = "string",
                        SqlQuery = "string",
                    },
                },
                GlossaryTerms = new[]
                {
                    new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArgs
                    {
                        Description = "string",
                        DisplayName = "string",
                        Labels = new[]
                        {
                            "string",
                        },
                    },
                },
                Options = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsArgs
                {
                    Analysis = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisArgs
                    {
                        Python = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPythonArgs
                        {
                            Enabled = false,
                        },
                    },
                    Datasource = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasourceArgs
                    {
                        BigQueryMaxBilledBytes = 0,
                    },
                },
                SchemaRelationships = new[]
                {
                    new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArgs
                    {
                        LeftSchemaPaths = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPathsArgs
                        {
                            Paths = new[]
                            {
                                "string",
                            },
                            TableFqn = "string",
                        },
                        RightSchemaPaths = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPathsArgs
                        {
                            Paths = new[]
                            {
                                "string",
                            },
                            TableFqn = "string",
                        },
                        ConfidenceScore = 0.0,
                        Sources = new[]
                        {
                            "string",
                        },
                    },
                },
                SystemInstruction = "string",
            },
            StagingContext = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs
            {
                DatasourceReferences = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs
                {
                    Bq = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs
                    {
                        TableReferences = new[]
                        {
                            new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs
                            {
                                DatasetId = "string",
                                ProjectId = "string",
                                TableId = "string",
                            },
                        },
                    },
                },
                ExampleQueries = new[]
                {
                    new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQueryArgs
                    {
                        NaturalLanguageQuestion = "string",
                        SqlQuery = "string",
                    },
                },
                GlossaryTerms = new[]
                {
                    new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTermArgs
                    {
                        Description = "string",
                        DisplayName = "string",
                        Labels = new[]
                        {
                            "string",
                        },
                    },
                },
                Options = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsArgs
                {
                    Analysis = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisArgs
                    {
                        Python = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPythonArgs
                        {
                            Enabled = false,
                        },
                    },
                    Datasource = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasourceArgs
                    {
                        BigQueryMaxBilledBytes = 0,
                    },
                },
                SchemaRelationships = new[]
                {
                    new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipArgs
                    {
                        LeftSchemaPaths = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPathsArgs
                        {
                            Paths = new[]
                            {
                                "string",
                            },
                            TableFqn = "string",
                        },
                        RightSchemaPaths = new Gcp.Gemini.Inputs.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPathsArgs
                        {
                            Paths = new[]
                            {
                                "string",
                            },
                            TableFqn = "string",
                        },
                        ConfidenceScore = 0.0,
                        Sources = new[]
                        {
                            "string",
                        },
                    },
                },
                SystemInstruction = "string",
            },
        },
        DeletionPolicy = "string",
        Description = "string",
        DisplayName = "string",
        KmsKey = "string",
        Labels = 
        {
            { "string", "string" },
        },
        Project = "string",
    });
    
    example, err := gemini.NewDataAnalyticsDataAgent(ctx, "dataAnalyticsDataAgentResource", &gemini.DataAnalyticsDataAgentArgs{
    	DataAgentId: pulumi.String("string"),
    	Location:    pulumi.String("string"),
    	DataAnalyticsAgent: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentArgs{
    		LastPublishedContexts: gemini.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextArray{
    			&gemini.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextArgs{
    				DatasourceReferences: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesArgs{
    					Bq: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqArgs{
    						TableReferences: gemini.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqTableReferenceArray{
    							&gemini.DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqTableReferenceArgs{
    								DatasetId: pulumi.String("string"),
    								ProjectId: pulumi.String("string"),
    								TableId:   pulumi.String("string"),
    							},
    						},
    					},
    				},
    				SystemInstruction: pulumi.String("string"),
    			},
    		},
    		PublishedContext: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextArgs{
    			DatasourceReferences: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesArgs{
    				Bq: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqArgs{
    					TableReferences: gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArray{
    						&gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArgs{
    							DatasetId: pulumi.String("string"),
    							ProjectId: pulumi.String("string"),
    							TableId:   pulumi.String("string"),
    						},
    					},
    				},
    			},
    			ExampleQueries: gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArray{
    				&gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArgs{
    					NaturalLanguageQuestion: pulumi.String("string"),
    					SqlQuery:                pulumi.String("string"),
    				},
    			},
    			GlossaryTerms: gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArray{
    				&gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArgs{
    					Description: pulumi.String("string"),
    					DisplayName: pulumi.String("string"),
    					Labels: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    				},
    			},
    			Options: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsArgs{
    				Analysis: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisArgs{
    					Python: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPythonArgs{
    						Enabled: pulumi.Bool(false),
    					},
    				},
    				Datasource: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasourceArgs{
    					BigQueryMaxBilledBytes: pulumi.Int(0),
    				},
    			},
    			SchemaRelationships: gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArray{
    				&gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArgs{
    					LeftSchemaPaths: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPathsArgs{
    						Paths: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    						TableFqn: pulumi.String("string"),
    					},
    					RightSchemaPaths: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPathsArgs{
    						Paths: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    						TableFqn: pulumi.String("string"),
    					},
    					ConfidenceScore: pulumi.Float64(0),
    					Sources: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    				},
    			},
    			SystemInstruction: pulumi.String("string"),
    		},
    		StagingContext: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs{
    			DatasourceReferences: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs{
    				Bq: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs{
    					TableReferences: gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArray{
    						&gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs{
    							DatasetId: pulumi.String("string"),
    							ProjectId: pulumi.String("string"),
    							TableId:   pulumi.String("string"),
    						},
    					},
    				},
    			},
    			ExampleQueries: gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQueryArray{
    				&gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQueryArgs{
    					NaturalLanguageQuestion: pulumi.String("string"),
    					SqlQuery:                pulumi.String("string"),
    				},
    			},
    			GlossaryTerms: gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTermArray{
    				&gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTermArgs{
    					Description: pulumi.String("string"),
    					DisplayName: pulumi.String("string"),
    					Labels: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    				},
    			},
    			Options: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsArgs{
    				Analysis: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisArgs{
    					Python: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPythonArgs{
    						Enabled: pulumi.Bool(false),
    					},
    				},
    				Datasource: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasourceArgs{
    					BigQueryMaxBilledBytes: pulumi.Int(0),
    				},
    			},
    			SchemaRelationships: gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipArray{
    				&gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipArgs{
    					LeftSchemaPaths: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPathsArgs{
    						Paths: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    						TableFqn: pulumi.String("string"),
    					},
    					RightSchemaPaths: &gemini.DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPathsArgs{
    						Paths: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    						TableFqn: pulumi.String("string"),
    					},
    					ConfidenceScore: pulumi.Float64(0),
    					Sources: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    				},
    			},
    			SystemInstruction: pulumi.String("string"),
    		},
    	},
    	DeletionPolicy: pulumi.String("string"),
    	Description:    pulumi.String("string"),
    	DisplayName:    pulumi.String("string"),
    	KmsKey:         pulumi.String("string"),
    	Labels: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	Project: pulumi.String("string"),
    })
    
    resource "gcp_gemini_data_analytics_data_agent" "dataAnalyticsDataAgentResource" {
      lifecycle {
        create_before_destroy = true
      }
      data_agent_id = "string"
      location      = "string"
      data_analytics_agent = {
        last_published_contexts = [{
          datasource_references = {
            bq = {
              table_references = [{
                dataset_id = "string"
                project_id = "string"
                table_id   = "string"
              }]
            }
          }
          system_instruction = "string"
        }]
        published_context = {
          datasource_references = {
            bq = {
              table_references = [{
                dataset_id = "string"
                project_id = "string"
                table_id   = "string"
              }]
            }
          }
          example_queries = [{
            natural_language_question = "string"
            sql_query                 = "string"
          }]
          glossary_terms = [{
            description  = "string"
            display_name = "string"
            labels       = ["string"]
          }]
          options = {
            analysis = {
              python = {
                enabled = false
              }
            }
            datasource = {
              big_query_max_billed_bytes = 0
            }
          }
          schema_relationships = [{
            left_schema_paths = {
              paths     = ["string"]
              table_fqn = "string"
            }
            right_schema_paths = {
              paths     = ["string"]
              table_fqn = "string"
            }
            confidence_score = 0
            sources          = ["string"]
          }]
          system_instruction = "string"
        }
        staging_context = {
          datasource_references = {
            bq = {
              table_references = [{
                dataset_id = "string"
                project_id = "string"
                table_id   = "string"
              }]
            }
          }
          example_queries = [{
            natural_language_question = "string"
            sql_query                 = "string"
          }]
          glossary_terms = [{
            description  = "string"
            display_name = "string"
            labels       = ["string"]
          }]
          options = {
            analysis = {
              python = {
                enabled = false
              }
            }
            datasource = {
              big_query_max_billed_bytes = 0
            }
          }
          schema_relationships = [{
            left_schema_paths = {
              paths     = ["string"]
              table_fqn = "string"
            }
            right_schema_paths = {
              paths     = ["string"]
              table_fqn = "string"
            }
            confidence_score = 0
            sources          = ["string"]
          }]
          system_instruction = "string"
        }
      }
      deletion_policy = "string"
      description     = "string"
      display_name    = "string"
      kms_key         = "string"
      labels = {
        "string" = "string"
      }
      project = "string"
    }
    
    var dataAnalyticsDataAgentResource = new DataAnalyticsDataAgent("dataAnalyticsDataAgentResource", DataAnalyticsDataAgentArgs.builder()
        .dataAgentId("string")
        .location("string")
        .dataAnalyticsAgent(DataAnalyticsDataAgentDataAnalyticsAgentArgs.builder()
            .lastPublishedContexts(DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextArgs.builder()
                .datasourceReferences(DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesArgs.builder()
                    .bq(DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqArgs.builder()
                        .tableReferences(DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqTableReferenceArgs.builder()
                            .datasetId("string")
                            .projectId("string")
                            .tableId("string")
                            .build())
                        .build())
                    .build())
                .systemInstruction("string")
                .build())
            .publishedContext(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextArgs.builder()
                .datasourceReferences(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesArgs.builder()
                    .bq(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqArgs.builder()
                        .tableReferences(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArgs.builder()
                            .datasetId("string")
                            .projectId("string")
                            .tableId("string")
                            .build())
                        .build())
                    .build())
                .exampleQueries(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArgs.builder()
                    .naturalLanguageQuestion("string")
                    .sqlQuery("string")
                    .build())
                .glossaryTerms(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArgs.builder()
                    .description("string")
                    .displayName("string")
                    .labels("string")
                    .build())
                .options(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsArgs.builder()
                    .analysis(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisArgs.builder()
                        .python(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPythonArgs.builder()
                            .enabled(false)
                            .build())
                        .build())
                    .datasource(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasourceArgs.builder()
                        .bigQueryMaxBilledBytes(0)
                        .build())
                    .build())
                .schemaRelationships(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArgs.builder()
                    .leftSchemaPaths(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPathsArgs.builder()
                        .paths("string")
                        .tableFqn("string")
                        .build())
                    .rightSchemaPaths(DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPathsArgs.builder()
                        .paths("string")
                        .tableFqn("string")
                        .build())
                    .confidenceScore(0.0)
                    .sources("string")
                    .build())
                .systemInstruction("string")
                .build())
            .stagingContext(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs.builder()
                .datasourceReferences(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs.builder()
                    .bq(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs.builder()
                        .tableReferences(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs.builder()
                            .datasetId("string")
                            .projectId("string")
                            .tableId("string")
                            .build())
                        .build())
                    .build())
                .exampleQueries(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQueryArgs.builder()
                    .naturalLanguageQuestion("string")
                    .sqlQuery("string")
                    .build())
                .glossaryTerms(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTermArgs.builder()
                    .description("string")
                    .displayName("string")
                    .labels("string")
                    .build())
                .options(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsArgs.builder()
                    .analysis(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisArgs.builder()
                        .python(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPythonArgs.builder()
                            .enabled(false)
                            .build())
                        .build())
                    .datasource(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasourceArgs.builder()
                        .bigQueryMaxBilledBytes(0)
                        .build())
                    .build())
                .schemaRelationships(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipArgs.builder()
                    .leftSchemaPaths(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPathsArgs.builder()
                        .paths("string")
                        .tableFqn("string")
                        .build())
                    .rightSchemaPaths(DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPathsArgs.builder()
                        .paths("string")
                        .tableFqn("string")
                        .build())
                    .confidenceScore(0.0)
                    .sources("string")
                    .build())
                .systemInstruction("string")
                .build())
            .build())
        .deletionPolicy("string")
        .description("string")
        .displayName("string")
        .kmsKey("string")
        .labels(Map.of("string", "string"))
        .project("string")
        .build());
    
    data_analytics_data_agent_resource = gcp.gemini.DataAnalyticsDataAgent("dataAnalyticsDataAgentResource",
        data_agent_id="string",
        location="string",
        data_analytics_agent={
            "last_published_contexts": [{
                "datasource_references": {
                    "bq": {
                        "table_references": [{
                            "dataset_id": "string",
                            "project_id": "string",
                            "table_id": "string",
                        }],
                    },
                },
                "system_instruction": "string",
            }],
            "published_context": {
                "datasource_references": {
                    "bq": {
                        "table_references": [{
                            "dataset_id": "string",
                            "project_id": "string",
                            "table_id": "string",
                        }],
                    },
                },
                "example_queries": [{
                    "natural_language_question": "string",
                    "sql_query": "string",
                }],
                "glossary_terms": [{
                    "description": "string",
                    "display_name": "string",
                    "labels": ["string"],
                }],
                "options": {
                    "analysis": {
                        "python": {
                            "enabled": False,
                        },
                    },
                    "datasource": {
                        "big_query_max_billed_bytes": 0,
                    },
                },
                "schema_relationships": [{
                    "left_schema_paths": {
                        "paths": ["string"],
                        "table_fqn": "string",
                    },
                    "right_schema_paths": {
                        "paths": ["string"],
                        "table_fqn": "string",
                    },
                    "confidence_score": float(0),
                    "sources": ["string"],
                }],
                "system_instruction": "string",
            },
            "staging_context": {
                "datasource_references": {
                    "bq": {
                        "table_references": [{
                            "dataset_id": "string",
                            "project_id": "string",
                            "table_id": "string",
                        }],
                    },
                },
                "example_queries": [{
                    "natural_language_question": "string",
                    "sql_query": "string",
                }],
                "glossary_terms": [{
                    "description": "string",
                    "display_name": "string",
                    "labels": ["string"],
                }],
                "options": {
                    "analysis": {
                        "python": {
                            "enabled": False,
                        },
                    },
                    "datasource": {
                        "big_query_max_billed_bytes": 0,
                    },
                },
                "schema_relationships": [{
                    "left_schema_paths": {
                        "paths": ["string"],
                        "table_fqn": "string",
                    },
                    "right_schema_paths": {
                        "paths": ["string"],
                        "table_fqn": "string",
                    },
                    "confidence_score": float(0),
                    "sources": ["string"],
                }],
                "system_instruction": "string",
            },
        },
        deletion_policy="string",
        description="string",
        display_name="string",
        kms_key="string",
        labels={
            "string": "string",
        },
        project="string")
    
    const dataAnalyticsDataAgentResource = new gcp.gemini.DataAnalyticsDataAgent("dataAnalyticsDataAgentResource", {
        dataAgentId: "string",
        location: "string",
        dataAnalyticsAgent: {
            lastPublishedContexts: [{
                datasourceReferences: {
                    bq: {
                        tableReferences: [{
                            datasetId: "string",
                            projectId: "string",
                            tableId: "string",
                        }],
                    },
                },
                systemInstruction: "string",
            }],
            publishedContext: {
                datasourceReferences: {
                    bq: {
                        tableReferences: [{
                            datasetId: "string",
                            projectId: "string",
                            tableId: "string",
                        }],
                    },
                },
                exampleQueries: [{
                    naturalLanguageQuestion: "string",
                    sqlQuery: "string",
                }],
                glossaryTerms: [{
                    description: "string",
                    displayName: "string",
                    labels: ["string"],
                }],
                options: {
                    analysis: {
                        python: {
                            enabled: false,
                        },
                    },
                    datasource: {
                        bigQueryMaxBilledBytes: 0,
                    },
                },
                schemaRelationships: [{
                    leftSchemaPaths: {
                        paths: ["string"],
                        tableFqn: "string",
                    },
                    rightSchemaPaths: {
                        paths: ["string"],
                        tableFqn: "string",
                    },
                    confidenceScore: 0,
                    sources: ["string"],
                }],
                systemInstruction: "string",
            },
            stagingContext: {
                datasourceReferences: {
                    bq: {
                        tableReferences: [{
                            datasetId: "string",
                            projectId: "string",
                            tableId: "string",
                        }],
                    },
                },
                exampleQueries: [{
                    naturalLanguageQuestion: "string",
                    sqlQuery: "string",
                }],
                glossaryTerms: [{
                    description: "string",
                    displayName: "string",
                    labels: ["string"],
                }],
                options: {
                    analysis: {
                        python: {
                            enabled: false,
                        },
                    },
                    datasource: {
                        bigQueryMaxBilledBytes: 0,
                    },
                },
                schemaRelationships: [{
                    leftSchemaPaths: {
                        paths: ["string"],
                        tableFqn: "string",
                    },
                    rightSchemaPaths: {
                        paths: ["string"],
                        tableFqn: "string",
                    },
                    confidenceScore: 0,
                    sources: ["string"],
                }],
                systemInstruction: "string",
            },
        },
        deletionPolicy: "string",
        description: "string",
        displayName: "string",
        kmsKey: "string",
        labels: {
            string: "string",
        },
        project: "string",
    });
    
    type: gcp:gemini:DataAnalyticsDataAgent
    properties:
        dataAgentId: string
        dataAnalyticsAgent:
            lastPublishedContexts:
                - datasourceReferences:
                    bq:
                        tableReferences:
                            - datasetId: string
                              projectId: string
                              tableId: string
                  systemInstruction: string
            publishedContext:
                datasourceReferences:
                    bq:
                        tableReferences:
                            - datasetId: string
                              projectId: string
                              tableId: string
                exampleQueries:
                    - naturalLanguageQuestion: string
                      sqlQuery: string
                glossaryTerms:
                    - description: string
                      displayName: string
                      labels:
                        - string
                options:
                    analysis:
                        python:
                            enabled: false
                    datasource:
                        bigQueryMaxBilledBytes: 0
                schemaRelationships:
                    - confidenceScore: 0
                      leftSchemaPaths:
                        paths:
                            - string
                        tableFqn: string
                      rightSchemaPaths:
                        paths:
                            - string
                        tableFqn: string
                      sources:
                        - string
                systemInstruction: string
            stagingContext:
                datasourceReferences:
                    bq:
                        tableReferences:
                            - datasetId: string
                              projectId: string
                              tableId: string
                exampleQueries:
                    - naturalLanguageQuestion: string
                      sqlQuery: string
                glossaryTerms:
                    - description: string
                      displayName: string
                      labels:
                        - string
                options:
                    analysis:
                        python:
                            enabled: false
                    datasource:
                        bigQueryMaxBilledBytes: 0
                schemaRelationships:
                    - confidenceScore: 0
                      leftSchemaPaths:
                        paths:
                            - string
                        tableFqn: string
                      rightSchemaPaths:
                        paths:
                            - string
                        tableFqn: string
                      sources:
                        - string
                systemInstruction: string
        deletionPolicy: string
        description: string
        displayName: string
        kmsKey: string
        labels:
            string: string
        location: string
        project: string
    

    DataAnalyticsDataAgent Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The DataAnalyticsDataAgent resource accepts the following input properties:

    DataAgentId string
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    Location string
    The location of the DataAgent.
    DataAnalyticsAgent DataAnalyticsDataAgentDataAnalyticsAgent
    Data analytics agent configuration. Structure is documented below.
    DeletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    Description string
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    DisplayName string
    Optional. User friendly display name. Must be between 1 and 256 characters.
    KmsKey string
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    Labels Dictionary<string, string>
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    DataAgentId string
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    Location string
    The location of the DataAgent.
    DataAnalyticsAgent DataAnalyticsDataAgentDataAnalyticsAgentArgs
    Data analytics agent configuration. Structure is documented below.
    DeletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    Description string
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    DisplayName string
    Optional. User friendly display name. Must be between 1 and 256 characters.
    KmsKey string
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    Labels map[string]string
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    data_agent_id string
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    location string
    The location of the DataAgent.
    data_analytics_agent object
    Data analytics agent configuration. Structure is documented below.
    deletion_policy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description string
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    display_name string
    Optional. User friendly display name. Must be between 1 and 256 characters.
    kms_key string
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels map(string)
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    dataAgentId String
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    location String
    The location of the DataAgent.
    dataAnalyticsAgent DataAnalyticsDataAgentDataAnalyticsAgent
    Data analytics agent configuration. Structure is documented below.
    deletionPolicy String
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description String
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    displayName String
    Optional. User friendly display name. Must be between 1 and 256 characters.
    kmsKey String
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels Map<String,String>
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    dataAgentId string
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    location string
    The location of the DataAgent.
    dataAnalyticsAgent DataAnalyticsDataAgentDataAnalyticsAgent
    Data analytics agent configuration. Structure is documented below.
    deletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description string
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    displayName string
    Optional. User friendly display name. Must be between 1 and 256 characters.
    kmsKey string
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels {[key: string]: string}
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    data_agent_id str
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    location str
    The location of the DataAgent.
    data_analytics_agent DataAnalyticsDataAgentDataAnalyticsAgentArgs
    Data analytics agent configuration. Structure is documented below.
    deletion_policy str
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description str
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    display_name str
    Optional. User friendly display name. Must be between 1 and 256 characters.
    kms_key str
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels Mapping[str, str]
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    dataAgentId String
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    location String
    The location of the DataAgent.
    dataAnalyticsAgent Property Map
    Data analytics agent configuration. Structure is documented below.
    deletionPolicy String
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description String
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    displayName String
    Optional. User friendly display name. Must be between 1 and 256 characters.
    kmsKey String
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels Map<String>
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the DataAnalyticsDataAgent resource produces the following output properties:

    CreateTime string
    Output only. The time when the data agent was created.
    DeleteTime string
    Output only. The time the data agent was soft deleted.
    EffectiveLabels Dictionary<string, string>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    PurgeTime string
    Output only. Timestamp in UTC of when this data agent is considered expired.
    UpdateTime string
    Output only. The time when the data agent was last updated.
    CreateTime string
    Output only. The time when the data agent was created.
    DeleteTime string
    Output only. The time the data agent was soft deleted.
    EffectiveLabels map[string]string
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    PurgeTime string
    Output only. Timestamp in UTC of when this data agent is considered expired.
    UpdateTime string
    Output only. The time when the data agent was last updated.
    create_time string
    Output only. The time when the data agent was created.
    delete_time string
    Output only. The time the data agent was soft deleted.
    effective_labels map(string)
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    pulumi_labels map(string)
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purge_time string
    Output only. Timestamp in UTC of when this data agent is considered expired.
    update_time string
    Output only. The time when the data agent was last updated.
    createTime String
    Output only. The time when the data agent was created.
    deleteTime String
    Output only. The time the data agent was soft deleted.
    effectiveLabels Map<String,String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purgeTime String
    Output only. Timestamp in UTC of when this data agent is considered expired.
    updateTime String
    Output only. The time when the data agent was last updated.
    createTime string
    Output only. The time when the data agent was created.
    deleteTime string
    Output only. The time the data agent was soft deleted.
    effectiveLabels {[key: string]: string}
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purgeTime string
    Output only. Timestamp in UTC of when this data agent is considered expired.
    updateTime string
    Output only. The time when the data agent was last updated.
    create_time str
    Output only. The time when the data agent was created.
    delete_time str
    Output only. The time the data agent was soft deleted.
    effective_labels Mapping[str, str]
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id str
    The provider-assigned unique ID for this managed resource.
    name str
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purge_time str
    Output only. Timestamp in UTC of when this data agent is considered expired.
    update_time str
    Output only. The time when the data agent was last updated.
    createTime String
    Output only. The time when the data agent was created.
    deleteTime String
    Output only. The time the data agent was soft deleted.
    effectiveLabels Map<String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purgeTime String
    Output only. Timestamp in UTC of when this data agent is considered expired.
    updateTime String
    Output only. The time when the data agent was last updated.

    Look up Existing DataAnalyticsDataAgent Resource

    Get an existing DataAnalyticsDataAgent resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: DataAnalyticsDataAgentState, opts?: CustomResourceOptions): DataAnalyticsDataAgent
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            create_time: Optional[str] = None,
            data_agent_id: Optional[str] = None,
            data_analytics_agent: Optional[DataAnalyticsDataAgentDataAnalyticsAgentArgs] = None,
            delete_time: Optional[str] = None,
            deletion_policy: Optional[str] = None,
            description: Optional[str] = None,
            display_name: Optional[str] = None,
            effective_labels: Optional[Mapping[str, str]] = None,
            kms_key: Optional[str] = None,
            labels: Optional[Mapping[str, str]] = None,
            location: Optional[str] = None,
            name: Optional[str] = None,
            project: Optional[str] = None,
            pulumi_labels: Optional[Mapping[str, str]] = None,
            purge_time: Optional[str] = None,
            update_time: Optional[str] = None) -> DataAnalyticsDataAgent
    func GetDataAnalyticsDataAgent(ctx *Context, name string, id IDInput, state *DataAnalyticsDataAgentState, opts ...ResourceOption) (*DataAnalyticsDataAgent, error)
    public static DataAnalyticsDataAgent Get(string name, Input<string> id, DataAnalyticsDataAgentState? state, CustomResourceOptions? opts = null)
    public static DataAnalyticsDataAgent get(String name, Output<String> id, DataAnalyticsDataAgentState state, CustomResourceOptions options)
    resources:  _:    type: gcp:gemini:DataAnalyticsDataAgent    get:      id: ${id}
    import {
      to = gcp_gemini_data_analytics_data_agent.example
      id = "${id}"
    }
    
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    CreateTime string
    Output only. The time when the data agent was created.
    DataAgentId string
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    DataAnalyticsAgent DataAnalyticsDataAgentDataAnalyticsAgent
    Data analytics agent configuration. Structure is documented below.
    DeleteTime string
    Output only. The time the data agent was soft deleted.
    DeletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    Description string
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    DisplayName string
    Optional. User friendly display name. Must be between 1 and 256 characters.
    EffectiveLabels Dictionary<string, string>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    KmsKey string
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    Labels Dictionary<string, string>
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    Location string
    The location of the DataAgent.
    Name string
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PulumiLabels Dictionary<string, string>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    PurgeTime string
    Output only. Timestamp in UTC of when this data agent is considered expired.
    UpdateTime string
    Output only. The time when the data agent was last updated.
    CreateTime string
    Output only. The time when the data agent was created.
    DataAgentId string
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    DataAnalyticsAgent DataAnalyticsDataAgentDataAnalyticsAgentArgs
    Data analytics agent configuration. Structure is documented below.
    DeleteTime string
    Output only. The time the data agent was soft deleted.
    DeletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    Description string
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    DisplayName string
    Optional. User friendly display name. Must be between 1 and 256 characters.
    EffectiveLabels map[string]string
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    KmsKey string
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    Labels map[string]string
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    Location string
    The location of the DataAgent.
    Name string
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    PulumiLabels map[string]string
    The combination of labels configured directly on the resource and default labels configured on the provider.
    PurgeTime string
    Output only. Timestamp in UTC of when this data agent is considered expired.
    UpdateTime string
    Output only. The time when the data agent was last updated.
    create_time string
    Output only. The time when the data agent was created.
    data_agent_id string
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    data_analytics_agent object
    Data analytics agent configuration. Structure is documented below.
    delete_time string
    Output only. The time the data agent was soft deleted.
    deletion_policy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description string
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    display_name string
    Optional. User friendly display name. Must be between 1 and 256 characters.
    effective_labels map(string)
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    kms_key string
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels map(string)
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location string
    The location of the DataAgent.
    name string
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumi_labels map(string)
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purge_time string
    Output only. Timestamp in UTC of when this data agent is considered expired.
    update_time string
    Output only. The time when the data agent was last updated.
    createTime String
    Output only. The time when the data agent was created.
    dataAgentId String
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    dataAnalyticsAgent DataAnalyticsDataAgentDataAnalyticsAgent
    Data analytics agent configuration. Structure is documented below.
    deleteTime String
    Output only. The time the data agent was soft deleted.
    deletionPolicy String
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description String
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    displayName String
    Optional. User friendly display name. Must be between 1 and 256 characters.
    effectiveLabels Map<String,String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    kmsKey String
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels Map<String,String>
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location String
    The location of the DataAgent.
    name String
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels Map<String,String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purgeTime String
    Output only. Timestamp in UTC of when this data agent is considered expired.
    updateTime String
    Output only. The time when the data agent was last updated.
    createTime string
    Output only. The time when the data agent was created.
    dataAgentId string
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    dataAnalyticsAgent DataAnalyticsDataAgentDataAnalyticsAgent
    Data analytics agent configuration. Structure is documented below.
    deleteTime string
    Output only. The time the data agent was soft deleted.
    deletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description string
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    displayName string
    Optional. User friendly display name. Must be between 1 and 256 characters.
    effectiveLabels {[key: string]: string}
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    kmsKey string
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels {[key: string]: string}
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location string
    The location of the DataAgent.
    name string
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels {[key: string]: string}
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purgeTime string
    Output only. Timestamp in UTC of when this data agent is considered expired.
    updateTime string
    Output only. The time when the data agent was last updated.
    create_time str
    Output only. The time when the data agent was created.
    data_agent_id str
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    data_analytics_agent DataAnalyticsDataAgentDataAnalyticsAgentArgs
    Data analytics agent configuration. Structure is documented below.
    delete_time str
    Output only. The time the data agent was soft deleted.
    deletion_policy str
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description str
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    display_name str
    Optional. User friendly display name. Must be between 1 and 256 characters.
    effective_labels Mapping[str, str]
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    kms_key str
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels Mapping[str, str]
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location str
    The location of the DataAgent.
    name str
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumi_labels Mapping[str, str]
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purge_time str
    Output only. Timestamp in UTC of when this data agent is considered expired.
    update_time str
    Output only. The time when the data agent was last updated.
    createTime String
    Output only. The time when the data agent was created.
    dataAgentId String
    Required. The ID to use for the DataAgent, which becomes the final component of the resource name. The ID must start with a lowercase letter and may contain lowercase letters, digits, underscores, and hyphens, up to 63 characters in total.
    dataAnalyticsAgent Property Map
    Data analytics agent configuration. Structure is documented below.
    deleteTime String
    Output only. The time the data agent was soft deleted.
    deletionPolicy String
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description String
    Optional. Description of the agent. Must be between 1 and 1024 characters.
    displayName String
    Optional. User friendly display name. Must be between 1 and 256 characters.
    effectiveLabels Map<String>
    All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
    kmsKey String
    Optional. Customer managed encryption key (CMEK) to use for encrypting the DataAgent resources. Cloud KMS CryptoKeys must reside in the same location as the DataAgent. The expected format is projects//locations//keyRings//cryptoKeys/.
    labels Map<String>
    Optional. Labels to help users filter related agents. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effectiveLabels for all of the labels present on the resource.
    location String
    The location of the DataAgent.
    name String
    Output only. Identifier. The unique resource name of a DataAgent. Format: projects/{project}/locations/{location}/dataAgents/{dataAgentId}
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    pulumiLabels Map<String>
    The combination of labels configured directly on the resource and default labels configured on the provider.
    purgeTime String
    Output only. Timestamp in UTC of when this data agent is considered expired.
    updateTime String
    Output only. The time when the data agent was last updated.

    Supporting Types

    DataAnalyticsDataAgentDataAnalyticsAgent, DataAnalyticsDataAgentDataAnalyticsAgentArgs

    LastPublishedContexts List<DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContext>
    (Output) Output only. The last published context for the agent. Structure is documented below.
    PublishedContext DataAnalyticsDataAgentDataAnalyticsAgentPublishedContext
    Optional. The published context for the agent. This context is used by the Chat API in production. Structure is documented below.
    StagingContext DataAnalyticsDataAgentDataAnalyticsAgentStagingContext
    Optional. The staging context for the agent. This context is used to test and validate changes before publishing. Structure is documented below.
    LastPublishedContexts []DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContext
    (Output) Output only. The last published context for the agent. Structure is documented below.
    PublishedContext DataAnalyticsDataAgentDataAnalyticsAgentPublishedContext
    Optional. The published context for the agent. This context is used by the Chat API in production. Structure is documented below.
    StagingContext DataAnalyticsDataAgentDataAnalyticsAgentStagingContext
    Optional. The staging context for the agent. This context is used to test and validate changes before publishing. Structure is documented below.
    last_published_contexts list(object)
    (Output) Output only. The last published context for the agent. Structure is documented below.
    published_context object
    Optional. The published context for the agent. This context is used by the Chat API in production. Structure is documented below.
    staging_context object
    Optional. The staging context for the agent. This context is used to test and validate changes before publishing. Structure is documented below.
    lastPublishedContexts List<DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContext>
    (Output) Output only. The last published context for the agent. Structure is documented below.
    publishedContext DataAnalyticsDataAgentDataAnalyticsAgentPublishedContext
    Optional. The published context for the agent. This context is used by the Chat API in production. Structure is documented below.
    stagingContext DataAnalyticsDataAgentDataAnalyticsAgentStagingContext
    Optional. The staging context for the agent. This context is used to test and validate changes before publishing. Structure is documented below.
    lastPublishedContexts DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContext[]
    (Output) Output only. The last published context for the agent. Structure is documented below.
    publishedContext DataAnalyticsDataAgentDataAnalyticsAgentPublishedContext
    Optional. The published context for the agent. This context is used by the Chat API in production. Structure is documented below.
    stagingContext DataAnalyticsDataAgentDataAnalyticsAgentStagingContext
    Optional. The staging context for the agent. This context is used to test and validate changes before publishing. Structure is documented below.
    last_published_contexts Sequence[DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContext]
    (Output) Output only. The last published context for the agent. Structure is documented below.
    published_context DataAnalyticsDataAgentDataAnalyticsAgentPublishedContext
    Optional. The published context for the agent. This context is used by the Chat API in production. Structure is documented below.
    staging_context DataAnalyticsDataAgentDataAnalyticsAgentStagingContext
    Optional. The staging context for the agent. This context is used to test and validate changes before publishing. Structure is documented below.
    lastPublishedContexts List<Property Map>
    (Output) Output only. The last published context for the agent. Structure is documented below.
    publishedContext Property Map
    Optional. The published context for the agent. This context is used by the Chat API in production. Structure is documented below.
    stagingContext Property Map
    Optional. The staging context for the agent. This context is used to test and validate changes before publishing. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContext, DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextArgs

    DatasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferences
    Output only. Data sources that are available for answering questions.
    SystemInstruction string
    Output only. The basic entry point for data owners creating domain knowledge for the agent.
    DatasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferences
    Output only. Data sources that are available for answering questions.
    SystemInstruction string
    Output only. The basic entry point for data owners creating domain knowledge for the agent.
    datasource_references object
    Output only. Data sources that are available for answering questions.
    system_instruction string
    Output only. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferences
    Output only. Data sources that are available for answering questions.
    systemInstruction String
    Output only. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferences
    Output only. Data sources that are available for answering questions.
    systemInstruction string
    Output only. The basic entry point for data owners creating domain knowledge for the agent.
    datasource_references DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferences
    Output only. Data sources that are available for answering questions.
    system_instruction str
    Output only. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences Property Map
    Output only. Data sources that are available for answering questions.
    systemInstruction String
    Output only. The basic entry point for data owners creating domain knowledge for the agent.

    DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferences, DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesArgs

    Bq DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    Bq DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq object
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq Property Map
    References to BigQuery tables. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBq, DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqArgs

    table_references list(object)
    References to BigQuery tables. Structure is documented below.
    tableReferences List<Property Map>
    References to BigQuery tables. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqTableReference, DataAnalyticsDataAgentDataAnalyticsAgentLastPublishedContextDatasourceReferencesBqTableReferenceArgs

    DatasetId string
    The dataset that the table belongs to.
    ProjectId string
    The project that the table belongs to.
    TableId string
    The table ID.
    DatasetId string
    The dataset that the table belongs to.
    ProjectId string
    The project that the table belongs to.
    TableId string
    The table ID.
    dataset_id string
    The dataset that the table belongs to.
    project_id string
    The project that the table belongs to.
    table_id string
    The table ID.
    datasetId String
    The dataset that the table belongs to.
    projectId String
    The project that the table belongs to.
    tableId String
    The table ID.
    datasetId string
    The dataset that the table belongs to.
    projectId string
    The project that the table belongs to.
    tableId string
    The table ID.
    dataset_id str
    The dataset that the table belongs to.
    project_id str
    The project that the table belongs to.
    table_id str
    The table ID.
    datasetId String
    The dataset that the table belongs to.
    projectId String
    The project that the table belongs to.
    tableId String
    The table ID.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContext, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextArgs

    DatasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    ExampleQueries List<DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQuery>
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    GlossaryTerms List<DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTerm>
    Optional. Term definitions for the agent's domain. Structure is documented below.
    Options DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    SchemaRelationships List<DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationship>
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    SystemInstruction string
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    DatasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    ExampleQueries []DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQuery
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    GlossaryTerms []DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTerm
    Optional. Term definitions for the agent's domain. Structure is documented below.
    Options DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    SchemaRelationships []DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationship
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    SystemInstruction string
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasource_references object
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    example_queries list(object)
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossary_terms list(object)
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options object
    Optional. Additional options for the conversation. Structure is documented below.
    schema_relationships list(object)
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    system_instruction string
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    exampleQueries List<DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQuery>
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossaryTerms List<DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTerm>
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    schemaRelationships List<DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationship>
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    systemInstruction String
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    exampleQueries DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQuery[]
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossaryTerms DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTerm[]
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    schemaRelationships DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationship[]
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    systemInstruction string
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasource_references DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    example_queries Sequence[DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQuery]
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossary_terms Sequence[DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTerm]
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    schema_relationships Sequence[DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationship]
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    system_instruction str
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences Property Map
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    exampleQueries List<Property Map>
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossaryTerms List<Property Map>
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options Property Map
    Optional. Additional options for the conversation. Structure is documented below.
    schemaRelationships List<Property Map>
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    systemInstruction String
    Optional. The basic entry point for data owners creating domain knowledge for the agent.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferences, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesArgs

    Bq DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    Bq DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq object
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq Property Map
    References to BigQuery tables. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBq, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqArgs

    table_references list(object)
    References to BigQuery tables. Structure is documented below.
    tableReferences List<Property Map>
    References to BigQuery tables. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReference, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextDatasourceReferencesBqTableReferenceArgs

    DatasetId string
    The dataset that the table belongs to.
    ProjectId string
    The project that the table belongs to.
    TableId string
    The table ID.
    DatasetId string
    The dataset that the table belongs to.
    ProjectId string
    The project that the table belongs to.
    TableId string
    The table ID.
    dataset_id string
    The dataset that the table belongs to.
    project_id string
    The project that the table belongs to.
    table_id string
    The table ID.
    datasetId String
    The dataset that the table belongs to.
    projectId String
    The project that the table belongs to.
    tableId String
    The table ID.
    datasetId string
    The dataset that the table belongs to.
    projectId string
    The project that the table belongs to.
    tableId string
    The table ID.
    dataset_id str
    The dataset that the table belongs to.
    project_id str
    The project that the table belongs to.
    table_id str
    The table ID.
    datasetId String
    The dataset that the table belongs to.
    projectId String
    The project that the table belongs to.
    tableId String
    The table ID.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQuery, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextExampleQueryArgs

    NaturalLanguageQuestion string
    Optional. A natural language question that a user might ask.
    SqlQuery string
    Optional. The SQL query that should be generated to answer the natural language question.
    NaturalLanguageQuestion string
    Optional. A natural language question that a user might ask.
    SqlQuery string
    Optional. The SQL query that should be generated to answer the natural language question.
    natural_language_question string
    Optional. A natural language question that a user might ask.
    sql_query string
    Optional. The SQL query that should be generated to answer the natural language question.
    naturalLanguageQuestion String
    Optional. A natural language question that a user might ask.
    sqlQuery String
    Optional. The SQL query that should be generated to answer the natural language question.
    naturalLanguageQuestion string
    Optional. A natural language question that a user might ask.
    sqlQuery string
    Optional. The SQL query that should be generated to answer the natural language question.
    natural_language_question str
    Optional. A natural language question that a user might ask.
    sql_query str
    Optional. The SQL query that should be generated to answer the natural language question.
    naturalLanguageQuestion String
    Optional. A natural language question that a user might ask.
    sqlQuery String
    Optional. The SQL query that should be generated to answer the natural language question.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTerm, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextGlossaryTermArgs

    Description string
    Required. The description or meaning of the term.
    DisplayName string
    Required. User friendly display name of the glossary term.
    Labels List<string>
    Optional. A list of general purpose labels associated with this term.
    Description string
    Required. The description or meaning of the term.
    DisplayName string
    Required. User friendly display name of the glossary term.
    Labels []string
    Optional. A list of general purpose labels associated with this term.
    description string
    Required. The description or meaning of the term.
    display_name string
    Required. User friendly display name of the glossary term.
    labels list(string)
    Optional. A list of general purpose labels associated with this term.
    description String
    Required. The description or meaning of the term.
    displayName String
    Required. User friendly display name of the glossary term.
    labels List<String>
    Optional. A list of general purpose labels associated with this term.
    description string
    Required. The description or meaning of the term.
    displayName string
    Required. User friendly display name of the glossary term.
    labels string[]
    Optional. A list of general purpose labels associated with this term.
    description str
    Required. The description or meaning of the term.
    display_name str
    Required. User friendly display name of the glossary term.
    labels Sequence[str]
    Optional. A list of general purpose labels associated with this term.
    description String
    Required. The description or meaning of the term.
    displayName String
    Required. User friendly display name of the glossary term.
    labels List<String>
    Optional. A list of general purpose labels associated with this term.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptions, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsArgs

    Analysis DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    Datasource DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    Analysis DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    Datasource DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    analysis object
    Optional. Options for analysis. Structure is documented below.
    datasource object
    Optional. Options for datasource configuration. Structure is documented below.
    analysis DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    datasource DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    analysis DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    datasource DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    analysis DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    datasource DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    analysis Property Map
    Optional. Options for analysis. Structure is documented below.
    datasource Property Map
    Optional. Options for datasource configuration. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysis, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisArgs

    Python DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    Python DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    python object
    Optional. Options for Python analysis. Structure is documented below.
    python DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    python DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    python DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    python Property Map
    Optional. Options for Python analysis. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPython, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsAnalysisPythonArgs

    Enabled bool
    Optional. Whether to enable Python analysis. Defaults to false.
    Enabled bool
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled bool
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled Boolean
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled boolean
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled bool
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled Boolean
    Optional. Whether to enable Python analysis. Defaults to false.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasource, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextOptionsDatasourceArgs

    BigQueryMaxBilledBytes int
    Optional. Limits the bytes billed for each BigQuery query job.
    BigQueryMaxBilledBytes int
    Optional. Limits the bytes billed for each BigQuery query job.
    big_query_max_billed_bytes number
    Optional. Limits the bytes billed for each BigQuery query job.
    bigQueryMaxBilledBytes Integer
    Optional. Limits the bytes billed for each BigQuery query job.
    bigQueryMaxBilledBytes number
    Optional. Limits the bytes billed for each BigQuery query job.
    big_query_max_billed_bytes int
    Optional. Limits the bytes billed for each BigQuery query job.
    bigQueryMaxBilledBytes Number
    Optional. Limits the bytes billed for each BigQuery query job.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationship, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipArgs

    LeftSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    RightSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    ConfidenceScore double
    Optional. A confidence score for the suggested relationship.
    Sources List<string>
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    LeftSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    RightSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    ConfidenceScore float64
    Optional. A confidence score for the suggested relationship.
    Sources []string
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    left_schema_paths object
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    right_schema_paths object
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidence_score number
    Optional. A confidence score for the suggested relationship.
    sources list(string)
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    leftSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    rightSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidenceScore Double
    Optional. A confidence score for the suggested relationship.
    sources List<String>
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    leftSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    rightSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidenceScore number
    Optional. A confidence score for the suggested relationship.
    sources string[]
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    left_schema_paths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    right_schema_paths DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidence_score float
    Optional. A confidence score for the suggested relationship.
    sources Sequence[str]
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    leftSchemaPaths Property Map
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    rightSchemaPaths Property Map
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidenceScore Number
    Optional. A confidence score for the suggested relationship.
    sources List<String>
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPaths, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipLeftSchemaPathsArgs

    Paths List<string>
    Required. The ordered list of paths within the table schema.
    TableFqn string
    Required. The service-qualified full resource name of the table.
    Paths []string
    Required. The ordered list of paths within the table schema.
    TableFqn string
    Required. The service-qualified full resource name of the table.
    paths list(string)
    Required. The ordered list of paths within the table schema.
    table_fqn string
    Required. The service-qualified full resource name of the table.
    paths List<String>
    Required. The ordered list of paths within the table schema.
    tableFqn String
    Required. The service-qualified full resource name of the table.
    paths string[]
    Required. The ordered list of paths within the table schema.
    tableFqn string
    Required. The service-qualified full resource name of the table.
    paths Sequence[str]
    Required. The ordered list of paths within the table schema.
    table_fqn str
    Required. The service-qualified full resource name of the table.
    paths List<String>
    Required. The ordered list of paths within the table schema.
    tableFqn String
    Required. The service-qualified full resource name of the table.

    DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPaths, DataAnalyticsDataAgentDataAnalyticsAgentPublishedContextSchemaRelationshipRightSchemaPathsArgs

    Paths List<string>

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    TableFqn string
    Required. The service-qualified full resource name of the table.
    Paths []string

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    TableFqn string
    Required. The service-qualified full resource name of the table.
    paths list(string)

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    table_fqn string
    Required. The service-qualified full resource name of the table.
    paths List<String>

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    tableFqn String
    Required. The service-qualified full resource name of the table.
    paths string[]

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    tableFqn string
    Required. The service-qualified full resource name of the table.
    paths Sequence[str]

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    table_fqn str
    Required. The service-qualified full resource name of the table.
    paths List<String>

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    tableFqn String
    Required. The service-qualified full resource name of the table.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContext, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextArgs

    DatasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    ExampleQueries List<DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQuery>
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    GlossaryTerms List<DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTerm>
    Optional. Term definitions for the agent's domain. Structure is documented below.
    Options DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    SchemaRelationships List<DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationship>
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    SystemInstruction string
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    DatasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    ExampleQueries []DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQuery
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    GlossaryTerms []DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTerm
    Optional. Term definitions for the agent's domain. Structure is documented below.
    Options DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    SchemaRelationships []DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationship
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    SystemInstruction string
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasource_references object
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    example_queries list(object)
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossary_terms list(object)
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options object
    Optional. Additional options for the conversation. Structure is documented below.
    schema_relationships list(object)
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    system_instruction string
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    exampleQueries List<DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQuery>
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossaryTerms List<DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTerm>
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    schemaRelationships List<DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationship>
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    systemInstruction String
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    exampleQueries DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQuery[]
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossaryTerms DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTerm[]
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    schemaRelationships DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationship[]
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    systemInstruction string
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasource_references DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferences
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    example_queries Sequence[DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQuery]
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossary_terms Sequence[DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTerm]
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptions
    Optional. Additional options for the conversation. Structure is documented below.
    schema_relationships Sequence[DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationship]
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    system_instruction str
    Optional. The basic entry point for data owners creating domain knowledge for the agent.
    datasourceReferences Property Map
    Required. Data sources that are available for answering questions. This Terraform resource currently supports BigQuery table references. Structure is documented below.
    exampleQueries List<Property Map>
    Optional. A list of example queries for BigQuery data sources. Structure is documented below.
    glossaryTerms List<Property Map>
    Optional. Term definitions for the agent's domain. Structure is documented below.
    options Property Map
    Optional. Additional options for the conversation. Structure is documented below.
    schemaRelationships List<Property Map>
    Optional. Relationships between table schemas, including referencing and referenced columns. Structure is documented below.
    systemInstruction String
    Optional. The basic entry point for data owners creating domain knowledge for the agent.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferences, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesArgs

    Bq DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    Bq DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq object
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBq
    References to BigQuery tables. Structure is documented below.
    bq Property Map
    References to BigQuery tables. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBq, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqArgs

    table_references list(object)
    References to BigQuery tables. Structure is documented below.
    tableReferences List<Property Map>
    References to BigQuery tables. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReference, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextDatasourceReferencesBqTableReferenceArgs

    DatasetId string
    The dataset that the table belongs to.
    ProjectId string
    The project that the table belongs to.
    TableId string
    The table ID.
    DatasetId string
    The dataset that the table belongs to.
    ProjectId string
    The project that the table belongs to.
    TableId string
    The table ID.
    dataset_id string
    The dataset that the table belongs to.
    project_id string
    The project that the table belongs to.
    table_id string
    The table ID.
    datasetId String
    The dataset that the table belongs to.
    projectId String
    The project that the table belongs to.
    tableId String
    The table ID.
    datasetId string
    The dataset that the table belongs to.
    projectId string
    The project that the table belongs to.
    tableId string
    The table ID.
    dataset_id str
    The dataset that the table belongs to.
    project_id str
    The project that the table belongs to.
    table_id str
    The table ID.
    datasetId String
    The dataset that the table belongs to.
    projectId String
    The project that the table belongs to.
    tableId String
    The table ID.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQuery, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextExampleQueryArgs

    NaturalLanguageQuestion string
    Optional. A natural language question that a user might ask.
    SqlQuery string
    Optional. The SQL query that should be generated to answer the natural language question.
    NaturalLanguageQuestion string
    Optional. A natural language question that a user might ask.
    SqlQuery string
    Optional. The SQL query that should be generated to answer the natural language question.
    natural_language_question string
    Optional. A natural language question that a user might ask.
    sql_query string
    Optional. The SQL query that should be generated to answer the natural language question.
    naturalLanguageQuestion String
    Optional. A natural language question that a user might ask.
    sqlQuery String
    Optional. The SQL query that should be generated to answer the natural language question.
    naturalLanguageQuestion string
    Optional. A natural language question that a user might ask.
    sqlQuery string
    Optional. The SQL query that should be generated to answer the natural language question.
    natural_language_question str
    Optional. A natural language question that a user might ask.
    sql_query str
    Optional. The SQL query that should be generated to answer the natural language question.
    naturalLanguageQuestion String
    Optional. A natural language question that a user might ask.
    sqlQuery String
    Optional. The SQL query that should be generated to answer the natural language question.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTerm, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextGlossaryTermArgs

    Description string
    Required. The description or meaning of the term.
    DisplayName string
    Required. User friendly display name of the glossary term.
    Labels List<string>
    Optional. A list of general purpose labels associated with this term.
    Description string
    Required. The description or meaning of the term.
    DisplayName string
    Required. User friendly display name of the glossary term.
    Labels []string
    Optional. A list of general purpose labels associated with this term.
    description string
    Required. The description or meaning of the term.
    display_name string
    Required. User friendly display name of the glossary term.
    labels list(string)
    Optional. A list of general purpose labels associated with this term.
    description String
    Required. The description or meaning of the term.
    displayName String
    Required. User friendly display name of the glossary term.
    labels List<String>
    Optional. A list of general purpose labels associated with this term.
    description string
    Required. The description or meaning of the term.
    displayName string
    Required. User friendly display name of the glossary term.
    labels string[]
    Optional. A list of general purpose labels associated with this term.
    description str
    Required. The description or meaning of the term.
    display_name str
    Required. User friendly display name of the glossary term.
    labels Sequence[str]
    Optional. A list of general purpose labels associated with this term.
    description String
    Required. The description or meaning of the term.
    displayName String
    Required. User friendly display name of the glossary term.
    labels List<String>
    Optional. A list of general purpose labels associated with this term.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptions, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsArgs

    Analysis DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    Datasource DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    Analysis DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    Datasource DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    analysis object
    Optional. Options for analysis. Structure is documented below.
    datasource object
    Optional. Options for datasource configuration. Structure is documented below.
    analysis DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    datasource DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    analysis DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    datasource DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    analysis DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysis
    Optional. Options for analysis. Structure is documented below.
    datasource DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasource
    Optional. Options for datasource configuration. Structure is documented below.
    analysis Property Map
    Optional. Options for analysis. Structure is documented below.
    datasource Property Map
    Optional. Options for datasource configuration. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysis, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisArgs

    Python DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    Python DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    python object
    Optional. Options for Python analysis. Structure is documented below.
    python DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    python DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    python DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPython
    Optional. Options for Python analysis. Structure is documented below.
    python Property Map
    Optional. Options for Python analysis. Structure is documented below.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPython, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsAnalysisPythonArgs

    Enabled bool
    Optional. Whether to enable Python analysis. Defaults to false.
    Enabled bool
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled bool
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled Boolean
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled boolean
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled bool
    Optional. Whether to enable Python analysis. Defaults to false.
    enabled Boolean
    Optional. Whether to enable Python analysis. Defaults to false.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasource, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextOptionsDatasourceArgs

    BigQueryMaxBilledBytes int
    Optional. Limits the bytes billed for each BigQuery query job.
    BigQueryMaxBilledBytes int
    Optional. Limits the bytes billed for each BigQuery query job.
    big_query_max_billed_bytes number
    Optional. Limits the bytes billed for each BigQuery query job.
    bigQueryMaxBilledBytes Integer
    Optional. Limits the bytes billed for each BigQuery query job.
    bigQueryMaxBilledBytes number
    Optional. Limits the bytes billed for each BigQuery query job.
    big_query_max_billed_bytes int
    Optional. Limits the bytes billed for each BigQuery query job.
    bigQueryMaxBilledBytes Number
    Optional. Limits the bytes billed for each BigQuery query job.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationship, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipArgs

    LeftSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    RightSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    ConfidenceScore double
    Optional. A confidence score for the suggested relationship.
    Sources List<string>
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    LeftSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    RightSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    ConfidenceScore float64
    Optional. A confidence score for the suggested relationship.
    Sources []string
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    left_schema_paths object
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    right_schema_paths object
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidence_score number
    Optional. A confidence score for the suggested relationship.
    sources list(string)
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    leftSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    rightSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidenceScore Double
    Optional. A confidence score for the suggested relationship.
    sources List<String>
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    leftSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    rightSchemaPaths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidenceScore number
    Optional. A confidence score for the suggested relationship.
    sources string[]
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    left_schema_paths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPaths
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    right_schema_paths DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPaths
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidence_score float
    Optional. A confidence score for the suggested relationship.
    sources Sequence[str]
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.
    leftSchemaPaths Property Map
    Required. An ordered list of fields for the left side of the join. Structure is documented below.
    rightSchemaPaths Property Map
    Required. An ordered list of fields for the right side of the join. Structure is documented below.
    confidenceScore Number
    Optional. A confidence score for the suggested relationship.
    sources List<String>
    Optional. Sources which generated the schema relation edge. Possible values: BIGQUERY_JOB_HISTORY, LLM_SUGGESTED, BIGQUERY_TABLE_CONSTRAINTS.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPaths, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipLeftSchemaPathsArgs

    Paths List<string>
    Required. The ordered list of paths within the table schema.
    TableFqn string
    Required. The service-qualified full resource name of the table.
    Paths []string
    Required. The ordered list of paths within the table schema.
    TableFqn string
    Required. The service-qualified full resource name of the table.
    paths list(string)
    Required. The ordered list of paths within the table schema.
    table_fqn string
    Required. The service-qualified full resource name of the table.
    paths List<String>
    Required. The ordered list of paths within the table schema.
    tableFqn String
    Required. The service-qualified full resource name of the table.
    paths string[]
    Required. The ordered list of paths within the table schema.
    tableFqn string
    Required. The service-qualified full resource name of the table.
    paths Sequence[str]
    Required. The ordered list of paths within the table schema.
    table_fqn str
    Required. The service-qualified full resource name of the table.
    paths List<String>
    Required. The ordered list of paths within the table schema.
    tableFqn String
    Required. The service-qualified full resource name of the table.

    DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPaths, DataAnalyticsDataAgentDataAnalyticsAgentStagingContextSchemaRelationshipRightSchemaPathsArgs

    Paths List<string>

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    TableFqn string
    Required. The service-qualified full resource name of the table.
    Paths []string

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    TableFqn string
    Required. The service-qualified full resource name of the table.
    paths list(string)

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    table_fqn string
    Required. The service-qualified full resource name of the table.
    paths List<String>

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    tableFqn String
    Required. The service-qualified full resource name of the table.
    paths string[]

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    tableFqn string
    Required. The service-qualified full resource name of the table.
    paths Sequence[str]

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    table_fqn str
    Required. The service-qualified full resource name of the table.
    paths List<String>

    Required. The ordered list of paths within the table schema.

    The lastPublishedContext block contains:

    tableFqn String
    Required. The service-qualified full resource name of the table.

    Import

    DataAgent can be imported using any of these accepted formats:

    • projects/{{project}}/locations/{{location}}/dataAgents/{{data_agent_id}}
    • {{project}}/{{location}}/{{data_agent_id}}
    • {{location}}/{{data_agent_id}}

    When using the pulumi import command, DataAgent can be imported using one of the formats above. For example:

    $ pulumi import gcp:gemini/dataAnalyticsDataAgent:DataAnalyticsDataAgent default projects/{{project}}/locations/{{location}}/dataAgents/{{data_agent_id}}
    $ pulumi import gcp:gemini/dataAnalyticsDataAgent:DataAnalyticsDataAgent default {{project}}/{{location}}/{{data_agent_id}}
    $ pulumi import gcp:gemini/dataAnalyticsDataAgent:DataAnalyticsDataAgent default {{location}}/{{data_agent_id}}
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Google Cloud (GCP) pulumi/pulumi-gcp
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the google-beta Terraform Provider.
    gcp logo
    Viewing docs for Google Cloud v10.2.0
    published on Tuesday, Oct 20, 2026 by Pulumi

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial