From fbe0b0883ca3a99616ab0f21de096e04db59c1f6 Mon Sep 17 00:00:00 2001 From: Pulumi Bot <30351955+pulumi-bot@users.noreply.github.com> Date: Wed, 15 Jan 2025 03:40:23 -0700 Subject: [PATCH] Automated SDK generation @ aws-cloudformation-user-guide 19dc52cd3f2007d6d268b65b739ffb5ebf8c1e76 (#1992) *Automated PR* --- .docs.version | 2 +- .../aws-bedrock-datasource.json | 2 +- .../aws-bedrock-knowledgebase.json | 370 ++- .../aws-databrew-dataset.json | 2 +- .../aws-databrew-job.json | 2 +- .../aws-databrew-project.json | 2 +- .../aws-databrew-recipe.json | 2 +- .../aws-databrew-ruleset.json | 2 +- .../aws-databrew-schedule.json | 2 +- .../aws-datazone-datasource.json | 27 +- .../aws-detective-graph.json | 8 + .../aws-detective-memberinvitation.json | 3 + .../aws-iot-thingtype.json | 4 +- ...ws-notificationscontacts-emailcontact.json | 122 + aws-cloudformation-schema/aws-sns-topic.json | 4 + .../aws-workspaces-connectionalias.json | 8 +- meta/.botocore.version | 2 +- meta/regions.json | 4 + .../pulumi-resource-aws-native/metadata.json | 276 +- .../pulumi-resource-aws-native/schema.json | 419 ++- sdk/dotnet/Bedrock/Enums.cs | 188 ++ sdk/dotnet/Bedrock/GetKnowledgeBase.cs | 7 + .../Inputs/KnowledgeBaseConfigurationArgs.cs | 3 + .../Inputs/KnowledgeBaseCuratedQueryArgs.cs | 29 + .../KnowledgeBaseQueryGenerationColumnArgs.cs | 32 + ...dgeBaseQueryGenerationConfigurationArgs.cs | 29 + ...KnowledgeBaseQueryGenerationContextArgs.cs | 39 + .../KnowledgeBaseQueryGenerationTableArgs.cs | 40 + .../KnowledgeBaseRedshiftConfigurationArgs.cs | 37 + ...edshiftProvisionedAuthConfigurationArgs.cs | 35 + ...aseRedshiftProvisionedConfigurationArgs.cs | 29 + ...eAwsDataCatalogStorageConfigurationArgs.cs | 31 + ...aseRedshiftQueryEngineConfigurationArgs.cs | 32 + ...yEngineRedshiftStorageConfigurationArgs.cs | 26 + ...hiftQueryEngineStorageConfigurationArgs.cs | 32 + ...RedshiftServerlessAuthConfigurationArgs.cs | 29 + ...BaseRedshiftServerlessConfigurationArgs.cs | 29 + ...geBaseSqlKnowledgeBaseConfigurationArgs.cs | 29 + sdk/dotnet/Bedrock/KnowledgeBase.cs | 7 +- .../Outputs/KnowledgeBaseConfiguration.cs | 4 + .../Outputs/KnowledgeBaseCuratedQuery.cs | 32 + .../KnowledgeBaseQueryGenerationColumn.cs | 36 + ...owledgeBaseQueryGenerationConfiguration.cs | 32 + .../KnowledgeBaseQueryGenerationContext.cs | 32 + .../KnowledgeBaseQueryGenerationTable.cs | 40 + .../KnowledgeBaseRedshiftConfiguration.cs | 36 + ...aseRedshiftProvisionedAuthConfiguration.cs | 39 + ...dgeBaseRedshiftProvisionedConfiguration.cs | 32 + ...ngineAwsDataCatalogStorageConfiguration.cs | 27 + ...dgeBaseRedshiftQueryEngineConfiguration.cs | 36 + ...QueryEngineRedshiftStorageConfiguration.cs | 27 + ...RedshiftQueryEngineStorageConfiguration.cs | 36 + ...BaseRedshiftServerlessAuthConfiguration.cs | 32 + ...edgeBaseRedshiftServerlessConfiguration.cs | 32 + ...wledgeBaseSqlKnowledgeBaseConfiguration.cs | 32 + sdk/dotnet/DataZone/DataSource.cs | 25 +- sdk/dotnet/DataZone/GetDataSource.cs | 7 + ...DataSourceGlueRunConfigurationInputArgs.cs | 6 + ...SourceRedshiftRunConfigurationInputArgs.cs | 8 +- .../DataSourceGlueRunConfigurationInput.cs | 7 + ...DataSourceRedshiftRunConfigurationInput.cs | 8 +- sdk/dotnet/Enums.cs | 4 + sdk/dotnet/Rds/DbInstance.cs | 6 +- sdk/dotnet/Rds/GetDbInstance.cs | 6 +- sdk/dotnet/Sns/GetTopic.cs | 4 + sdk/dotnet/Sns/Topic.cs | 6 + sdk/dotnet/Ssm/Association.cs | 4 +- sdk/dotnet/Ssm/GetAssociation.cs | 2 +- sdk/go/aws/bedrock/getKnowledgeBase.go | 7 + sdk/go/aws/bedrock/knowledgeBase.go | 7 +- sdk/go/aws/bedrock/pulumiEnums.go | 1036 ++++++- sdk/go/aws/bedrock/pulumiTypes.go | 2750 +++++++++++++++-- sdk/go/aws/datazone/dataSource.go | 32 +- sdk/go/aws/datazone/getDataSource.go | 7 + sdk/go/aws/datazone/pulumiTypes.go | 31 +- sdk/go/aws/iot/pulumiTypes.go | 4 +- sdk/go/aws/pulumiEnums.go | 2 + sdk/go/aws/rds/dbInstance.go | 12 +- sdk/go/aws/rds/getDbInstance.go | 12 +- sdk/go/aws/sns/getTopic.go | 7 +- sdk/go/aws/sns/topic.go | 13 +- sdk/go/aws/ssm/association.go | 8 +- sdk/go/aws/ssm/getAssociation.go | 4 +- sdk/nodejs/bedrock/getKnowledgeBase.ts | 4 + sdk/nodejs/bedrock/knowledgeBase.ts | 2 +- sdk/nodejs/datazone/dataSource.ts | 25 +- sdk/nodejs/datazone/getDataSource.ts | 4 + sdk/nodejs/rds/dbInstance.ts | 6 +- sdk/nodejs/rds/getDbInstance.ts | 6 +- sdk/nodejs/sns/getTopic.ts | 1 + sdk/nodejs/sns/topic.ts | 4 + sdk/nodejs/ssm/association.ts | 4 +- sdk/nodejs/ssm/getAssociation.ts | 2 +- sdk/nodejs/types/enums/bedrock/index.ts | 62 + sdk/nodejs/types/enums/index.ts | 4 + sdk/nodejs/types/input.ts | 137 +- sdk/nodejs/types/output.ts | 137 +- sdk/python/pulumi_aws_native/_enums.py | 4 + .../pulumi_aws_native/bedrock/_enums.py | 56 + .../pulumi_aws_native/bedrock/_inputs.py | 729 +++++ .../bedrock/get_knowledge_base.py | 17 +- .../bedrock/knowledge_base.py | 2 +- .../pulumi_aws_native/bedrock/outputs.py | 695 +++++ .../pulumi_aws_native/datazone/_inputs.py | 96 +- .../pulumi_aws_native/datazone/data_source.py | 76 +- .../datazone/get_data_source.py | 16 +- .../pulumi_aws_native/datazone/outputs.py | 68 +- .../pulumi_aws_native/rds/db_instance.py | 6 +- .../pulumi_aws_native/rds/get_db_instance.py | 6 +- sdk/python/pulumi_aws_native/sns/get_topic.py | 13 +- sdk/python/pulumi_aws_native/sns/topic.py | 21 + .../pulumi_aws_native/ssm/association.py | 8 +- .../pulumi_aws_native/ssm/get_association.py | 2 +- 113 files changed, 8200 insertions(+), 489 deletions(-) create mode 100644 aws-cloudformation-schema/aws-notificationscontacts-emailcontact.json create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseCuratedQueryArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationColumnArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationContextArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationTableArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftProvisionedConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftServerlessAuthConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftServerlessConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Inputs/KnowledgeBaseSqlKnowledgeBaseConfigurationArgs.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseCuratedQuery.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationColumn.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationContext.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationTable.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftProvisionedAuthConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftProvisionedConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineStorageConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftServerlessAuthConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftServerlessConfiguration.cs create mode 100644 sdk/dotnet/Bedrock/Outputs/KnowledgeBaseSqlKnowledgeBaseConfiguration.cs diff --git a/.docs.version b/.docs.version index 4c892c0be6..6b21abde2c 100644 --- a/.docs.version +++ b/.docs.version @@ -1 +1 @@ -29eb52b85ebd92cb43192f2e64ac182f537d657c +2bd0dbd05c1fb10774e9f755d87cede090b46e19 diff --git a/aws-cloudformation-schema/aws-bedrock-datasource.json b/aws-cloudformation-schema/aws-bedrock-datasource.json index dea2e72018..62508a44b5 100644 --- a/aws-cloudformation-schema/aws-bedrock-datasource.json +++ b/aws-cloudformation-schema/aws-bedrock-datasource.json @@ -104,7 +104,7 @@ "DataSourceType" : { "type" : "string", "description" : "The type of the data source location.", - "enum" : [ "S3", "CONFLUENCE", "SALESFORCE", "SHAREPOINT", "WEB", "CUSTOM" ] + "enum" : [ "S3", "CONFLUENCE", "SALESFORCE", "SHAREPOINT", "WEB", "CUSTOM", "REDSHIFT_METADATA" ] }, "DataDeletionPolicy" : { "type" : "string", diff --git a/aws-cloudformation-schema/aws-bedrock-knowledgebase.json b/aws-cloudformation-schema/aws-bedrock-knowledgebase.json index c657b6717b..ef82511f44 100644 --- a/aws-cloudformation-schema/aws-bedrock-knowledgebase.json +++ b/aws-cloudformation-schema/aws-bedrock-knowledgebase.json @@ -14,6 +14,9 @@ }, "KendraKnowledgeBaseConfiguration" : { "$ref" : "#/definitions/KendraKnowledgeBaseConfiguration" + }, + "SqlKnowledgeBaseConfiguration" : { + "$ref" : "#/definitions/SqlKnowledgeBaseConfiguration" } }, "required" : [ "Type" ], @@ -32,7 +35,7 @@ "KnowledgeBaseType" : { "type" : "string", "description" : "The type of a knowledge base.", - "enum" : [ "VECTOR", "KENDRA" ] + "enum" : [ "VECTOR", "KENDRA", "SQL" ] }, "OpenSearchServerlessConfiguration" : { "type" : "object", @@ -482,6 +485,369 @@ "type" : "string", "description" : "Arn of a Kendra index", "pattern" : "^arn:aws(|-cn|-us-gov):kendra:[a-z0-9-]{1,20}:([0-9]{12}|):index/([a-zA-Z0-9][a-zA-Z0-9-]{35}|[a-zA-Z0-9][a-zA-Z0-9-]{35}-[a-zA-Z0-9][a-zA-Z0-9-]{35})$" + }, + "SqlKnowledgeBaseConfiguration" : { + "type" : "object", + "description" : "Configurations for a SQL knowledge base", + "properties" : { + "Type" : { + "$ref" : "#/definitions/QueryEngineType" + }, + "RedshiftConfiguration" : { + "$ref" : "#/definitions/RedshiftConfiguration" + } + }, + "required" : [ "Type" ], + "additionalProperties" : false + }, + "QueryEngineType" : { + "type" : "string", + "description" : "SQL query engine type", + "enum" : [ "REDSHIFT" ] + }, + "RedshiftConfiguration" : { + "type" : "object", + "description" : "Configurations for a Redshift knowledge base", + "properties" : { + "StorageConfigurations" : { + "$ref" : "#/definitions/RedshiftQueryEngineStorageConfigurations" + }, + "QueryEngineConfiguration" : { + "$ref" : "#/definitions/RedshiftQueryEngineConfiguration" + }, + "QueryGenerationConfiguration" : { + "$ref" : "#/definitions/QueryGenerationConfiguration" + } + }, + "required" : [ "StorageConfigurations", "QueryEngineConfiguration" ], + "additionalProperties" : false + }, + "RedshiftQueryEngineStorageConfigurations" : { + "type" : "array", + "description" : "List of configurations for available Redshift query engine storage types", + "minItems" : 1, + "maxItems" : 1, + "items" : { + "$ref" : "#/definitions/RedshiftQueryEngineStorageConfiguration" + }, + "insertionOrder" : false + }, + "RedshiftQueryEngineStorageConfiguration" : { + "type" : "object", + "description" : "Configurations for available Redshift query engine storage types", + "properties" : { + "Type" : { + "$ref" : "#/definitions/RedshiftQueryEngineStorageType" + }, + "AwsDataCatalogConfiguration" : { + "$ref" : "#/definitions/RedshiftQueryEngineAwsDataCatalogStorageConfiguration" + }, + "RedshiftConfiguration" : { + "$ref" : "#/definitions/RedshiftQueryEngineRedshiftStorageConfiguration" + } + }, + "required" : [ "Type" ], + "additionalProperties" : false + }, + "RedshiftQueryEngineStorageType" : { + "type" : "string", + "description" : "Redshift query engine storage type", + "enum" : [ "REDSHIFT", "AWS_DATA_CATALOG" ] + }, + "RedshiftQueryEngineAwsDataCatalogStorageConfiguration" : { + "type" : "object", + "description" : "Configurations for Redshift query engine AWS Data Catalog backed storage", + "properties" : { + "TableNames" : { + "$ref" : "#/definitions/AwsDataCatalogTableNames" + } + }, + "required" : [ "TableNames" ], + "additionalProperties" : false + }, + "AwsDataCatalogTableNames" : { + "type" : "array", + "description" : "List of table names in AWS Data Catalog. Must follow two part notation", + "items" : { + "$ref" : "#/definitions/AwsDataCatalogTableName" + }, + "minItems" : 1, + "maxItems" : 1000, + "insertionOrder" : false + }, + "AwsDataCatalogTableName" : { + "type" : "string", + "description" : "AWS Data Catalog table name", + "pattern" : "^.*\\.*$", + "minLength" : 1, + "maxLength" : 200 + }, + "RedshiftQueryEngineRedshiftStorageConfiguration" : { + "type" : "object", + "description" : "Configurations for Redshift query engine Redshift backed storage", + "properties" : { + "DatabaseName" : { + "$ref" : "#/definitions/RedshiftDatabase" + } + }, + "required" : [ "DatabaseName" ], + "additionalProperties" : false + }, + "RedshiftDatabase" : { + "type" : "string", + "description" : "Redshift database name", + "minLength" : 1, + "maxLength" : 200 + }, + "RedshiftQueryEngineConfiguration" : { + "type" : "object", + "description" : "Configurations for Redshift query engine", + "properties" : { + "Type" : { + "$ref" : "#/definitions/RedshiftQueryEngineType" + }, + "ServerlessConfiguration" : { + "$ref" : "#/definitions/RedshiftServerlessConfiguration" + }, + "ProvisionedConfiguration" : { + "$ref" : "#/definitions/RedshiftProvisionedConfiguration" + } + }, + "required" : [ "Type" ], + "additionalProperties" : false + }, + "RedshiftQueryEngineType" : { + "type" : "string", + "description" : "Redshift query engine type", + "enum" : [ "SERVERLESS", "PROVISIONED" ] + }, + "RedshiftServerlessConfiguration" : { + "type" : "object", + "description" : "Configurations for serverless Redshift query engine", + "properties" : { + "WorkgroupArn" : { + "$ref" : "#/definitions/WorkgroupArn" + }, + "AuthConfiguration" : { + "$ref" : "#/definitions/RedshiftServerlessAuthConfiguration" + } + }, + "required" : [ "WorkgroupArn", "AuthConfiguration" ], + "additionalProperties" : false + }, + "WorkgroupArn" : { + "type" : "string", + "description" : "Workgroup arn", + "pattern" : "^(arn:(aws(-[a-z]+)*):redshift-serverless:[a-z]{2}(-gov)?-[a-z]+-\\d{1}:\\d{12}:workgroup/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$" + }, + "RedshiftServerlessAuthConfiguration" : { + "type" : "object", + "description" : "Configurations for Redshift query engine serverless auth setup", + "properties" : { + "Type" : { + "$ref" : "#/definitions/RedshiftServerlessAuthType" + }, + "UsernamePasswordSecretArn" : { + "$ref" : "#/definitions/SecretArn" + } + }, + "required" : [ "Type" ], + "additionalProperties" : false + }, + "RedshiftServerlessAuthType" : { + "type" : "string", + "description" : "Serverless Redshift auth type", + "enum" : [ "IAM", "USERNAME_PASSWORD" ] + }, + "SecretArn" : { + "type" : "string", + "description" : "Arn of a SecretsManager Secret", + "pattern" : "^arn:aws(|-cn|-us-gov):secretsmanager:[a-z0-9-]{1,20}:([0-9]{12}|):secret:[a-zA-Z0-9!/_+=.@-]{1,512}$" + }, + "RedshiftProvisionedConfiguration" : { + "type" : "object", + "description" : "Configurations for provisioned Redshift query engine", + "properties" : { + "ClusterIdentifier" : { + "$ref" : "#/definitions/RedshiftClusterIdentifier" + }, + "AuthConfiguration" : { + "$ref" : "#/definitions/RedshiftProvisionedAuthConfiguration" + } + }, + "required" : [ "ClusterIdentifier", "AuthConfiguration" ], + "additionalProperties" : false + }, + "RedshiftClusterIdentifier" : { + "type" : "string", + "description" : "Redshift cluster identifier", + "minLength" : 1, + "maxLength" : 63 + }, + "RedshiftProvisionedAuthConfiguration" : { + "type" : "object", + "description" : "Configurations for Redshift query engine provisioned auth setup", + "properties" : { + "Type" : { + "$ref" : "#/definitions/RedshiftProvisionedAuthType" + }, + "DatabaseUser" : { + "type" : "string", + "description" : "Redshift database user" + }, + "UsernamePasswordSecretArn" : { + "$ref" : "#/definitions/SecretArn" + } + }, + "required" : [ "Type" ], + "additionalProperties" : false + }, + "RedshiftProvisionedAuthType" : { + "type" : "string", + "description" : "Provisioned Redshift auth type", + "enum" : [ "IAM", "USERNAME_PASSWORD", "USERNAME" ] + }, + "QueryGenerationConfiguration" : { + "type" : "object", + "description" : "Configurations for generating Redshift engine queries", + "properties" : { + "ExecutionTimeoutSeconds" : { + "$ref" : "#/definitions/QueryExecutionTimeoutSeconds" + }, + "GenerationContext" : { + "$ref" : "#/definitions/QueryGenerationContext" + } + }, + "additionalProperties" : false + }, + "QueryExecutionTimeoutSeconds" : { + "type" : "integer", + "description" : "Max query execution timeout", + "minimum" : 1, + "maximum" : 200 + }, + "QueryGenerationContext" : { + "type" : "object", + "description" : "Context used to improve query generation", + "properties" : { + "Tables" : { + "$ref" : "#/definitions/QueryGenerationTables" + }, + "CuratedQueries" : { + "$ref" : "#/definitions/CuratedQueries" + } + }, + "additionalProperties" : false + }, + "QueryGenerationTables" : { + "type" : "array", + "description" : "List of tables used for Redshift query generation context", + "items" : { + "$ref" : "#/definitions/QueryGenerationTable" + }, + "maxItems" : 50, + "insertionOrder" : false + }, + "QueryGenerationTable" : { + "type" : "object", + "description" : "Tables used for Redshift query generation context", + "properties" : { + "Name" : { + "$ref" : "#/definitions/QueryGenerationTableName" + }, + "Description" : { + "$ref" : "#/definitions/DescriptionString" + }, + "Inclusion" : { + "$ref" : "#/definitions/InclusionType" + }, + "Columns" : { + "$ref" : "#/definitions/QueryGenerationColumns" + } + }, + "required" : [ "Name" ], + "additionalProperties" : false + }, + "QueryGenerationTableName" : { + "type" : "string", + "description" : "Query generation table name. Must follow three-part notation", + "pattern" : "^.*\\..*\\..*$" + }, + "DescriptionString" : { + "type" : "string", + "description" : "Description for the attached entity", + "minLength" : 1, + "maxLength" : 200 + }, + "InclusionType" : { + "type" : "string", + "description" : "Include or Exclude status for an entity", + "enum" : [ "INCLUDE", "EXCLUDE" ] + }, + "QueryGenerationColumns" : { + "type" : "array", + "description" : "List of Redshift query generation columns", + "items" : { + "$ref" : "#/definitions/QueryGenerationColumn" + }, + "insertionOrder" : false + }, + "QueryGenerationColumn" : { + "type" : "object", + "description" : "Redshift query generation column", + "properties" : { + "Name" : { + "$ref" : "#/definitions/QueryGenerationColumnName" + }, + "Description" : { + "$ref" : "#/definitions/DescriptionString" + }, + "Inclusion" : { + "$ref" : "#/definitions/InclusionType" + } + }, + "additionalProperties" : false + }, + "QueryGenerationColumnName" : { + "type" : "string", + "description" : "Query generation column name", + "minLength" : 1, + "maxLength" : 127 + }, + "CuratedQueries" : { + "type" : "array", + "description" : "List of example queries and results", + "maxItems" : 10, + "items" : { + "$ref" : "#/definitions/CuratedQuery" + }, + "insertionOrder" : false + }, + "CuratedQuery" : { + "type" : "object", + "description" : "Curated query or question and answer pair", + "properties" : { + "NaturalLanguage" : { + "$ref" : "#/definitions/NaturalLanguageString" + }, + "Sql" : { + "$ref" : "#/definitions/SqlString" + } + }, + "required" : [ "NaturalLanguage", "Sql" ], + "additionalProperties" : false + }, + "NaturalLanguageString" : { + "type" : "string", + "description" : "Question for the curated query", + "minLength" : 1, + "maxLength" : 1000 + }, + "SqlString" : { + "type" : "string", + "description" : "Answer for the curated query", + "minLength" : 1, + "maxLength" : 1000 } }, "properties" : { @@ -548,7 +914,7 @@ }, "required" : [ "KnowledgeBaseConfiguration", "Name", "RoleArn" ], "readOnlyProperties" : [ "/properties/KnowledgeBaseId", "/properties/KnowledgeBaseArn", "/properties/CreatedAt", "/properties/UpdatedAt", "/properties/FailureReasons", "/properties/Status" ], - "createOnlyProperties" : [ "/properties/StorageConfiguration", "/properties/KnowledgeBaseConfiguration" ], + "createOnlyProperties" : [ "/properties/StorageConfiguration", "/properties/KnowledgeBaseConfiguration/Type", "/properties/KnowledgeBaseConfiguration/VectorKnowledgeBaseConfiguration", "/properties/KnowledgeBaseConfiguration/KendraKnowledgeBaseConfiguration", "/properties/KnowledgeBaseConfiguration/SqlKnowledgeBaseConfiguration/Type", "/properties/KnowledgeBaseConfiguration/SqlKnowledgeBaseConfiguration/RedshiftConfiguration/StorageConfigurations", "/properties/KnowledgeBaseConfiguration/SqlKnowledgeBaseConfiguration/RedshiftConfiguration/QueryEngineConfiguration" ], "primaryIdentifier" : [ "/properties/KnowledgeBaseId" ], "handlers" : { "create" : { diff --git a/aws-cloudformation-schema/aws-databrew-dataset.json b/aws-cloudformation-schema/aws-databrew-dataset.json index 2fada31670..0ed17f9bf4 100644 --- a/aws-cloudformation-schema/aws-databrew-dataset.json +++ b/aws-cloudformation-schema/aws-databrew-dataset.json @@ -396,7 +396,7 @@ }, "handlers" : { "create" : { - "permissions" : [ "databrew:CreateDataset", "databrew:TagResource", "databrew:UntagResource", "glue:GetConnection", "glue:GetTable", "iam:PassRole" ] + "permissions" : [ "databrew:CreateDataset", "databrew:DescribeDataset", "databrew:TagResource", "databrew:UntagResource", "glue:GetConnection", "glue:GetTable", "iam:PassRole" ] }, "read" : { "permissions" : [ "databrew:DescribeDataset", "databrew:ListTagsForResource", "iam:ListRoles" ] diff --git a/aws-cloudformation-schema/aws-databrew-job.json b/aws-cloudformation-schema/aws-databrew-job.json index f26bbb61dc..a4f1e02e9e 100644 --- a/aws-cloudformation-schema/aws-databrew-job.json +++ b/aws-cloudformation-schema/aws-databrew-job.json @@ -524,7 +524,7 @@ }, "handlers" : { "create" : { - "permissions" : [ "databrew:CreateProfileJob", "databrew:CreateRecipeJob", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] + "permissions" : [ "databrew:CreateProfileJob", "databrew:CreateRecipeJob", "databrew:DescribeJob", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] }, "read" : { "permissions" : [ "databrew:DescribeJob", "databrew:ListTagsForResource", "iam:ListRoles" ] diff --git a/aws-cloudformation-schema/aws-databrew-project.json b/aws-cloudformation-schema/aws-databrew-project.json index c9fa34ef07..7884916b5b 100644 --- a/aws-cloudformation-schema/aws-databrew-project.json +++ b/aws-cloudformation-schema/aws-databrew-project.json @@ -89,7 +89,7 @@ }, "handlers" : { "create" : { - "permissions" : [ "databrew:CreateProject", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] + "permissions" : [ "databrew:CreateProject", "databrew:DescribeProject", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] }, "read" : { "permissions" : [ "databrew:DescribeProject", "databrew:ListTagsForResource", "iam:ListRoles" ] diff --git a/aws-cloudformation-schema/aws-databrew-recipe.json b/aws-cloudformation-schema/aws-databrew-recipe.json index b68743bfa2..c6a71e49d8 100644 --- a/aws-cloudformation-schema/aws-databrew-recipe.json +++ b/aws-cloudformation-schema/aws-databrew-recipe.json @@ -524,7 +524,7 @@ }, "handlers" : { "create" : { - "permissions" : [ "databrew:CreateRecipe", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] + "permissions" : [ "databrew:CreateRecipe", "databrew:DescribeRecipe", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] }, "read" : { "permissions" : [ "databrew:DescribeRecipe", "databrew:ListTagsForResource", "iam:ListRoles" ] diff --git a/aws-cloudformation-schema/aws-databrew-ruleset.json b/aws-cloudformation-schema/aws-databrew-ruleset.json index bed0cd37c0..dd811ac51a 100644 --- a/aws-cloudformation-schema/aws-databrew-ruleset.json +++ b/aws-cloudformation-schema/aws-databrew-ruleset.json @@ -194,7 +194,7 @@ }, "handlers" : { "create" : { - "permissions" : [ "databrew:CreateRuleset", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] + "permissions" : [ "databrew:CreateRuleset", "databrew:DescribeRuleset", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] }, "read" : { "permissions" : [ "databrew:DescribeRuleset", "databrew:ListTagsForResource", "iam:ListRoles" ] diff --git a/aws-cloudformation-schema/aws-databrew-schedule.json b/aws-cloudformation-schema/aws-databrew-schedule.json index e19b89e000..86267387a1 100644 --- a/aws-cloudformation-schema/aws-databrew-schedule.json +++ b/aws-cloudformation-schema/aws-databrew-schedule.json @@ -72,7 +72,7 @@ }, "handlers" : { "create" : { - "permissions" : [ "databrew:CreateSchedule", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] + "permissions" : [ "databrew:CreateSchedule", "databrew:DescribeSchedule", "databrew:TagResource", "databrew:UntagResource", "iam:PassRole" ] }, "read" : { "permissions" : [ "databrew:DescribeSchedule", "databrew:ListTagsForResource", "iam:ListRoles" ] diff --git a/aws-cloudformation-schema/aws-datazone-datasource.json b/aws-cloudformation-schema/aws-datazone-datasource.json index f217df192a..4442f59eb0 100644 --- a/aws-cloudformation-schema/aws-datazone-datasource.json +++ b/aws-cloudformation-schema/aws-datazone-datasource.json @@ -118,6 +118,12 @@ "description" : "Specifies whether to automatically import data quality metrics as part of the data source run.", "type" : "boolean" }, + "CatalogName" : { + "type" : "string", + "description" : "The catalog name in the AWS Glue run configuration.", + "maxLength" : 128, + "minLength" : 1 + }, "DataAccessRole" : { "description" : "The data access role included in the configuration details of the AWS Glue data source.", "$ref" : "#/definitions/DataAccessRole" @@ -194,7 +200,7 @@ "$ref" : "#/definitions/RedshiftStorage" } }, - "required" : [ "RedshiftCredentialConfiguration", "RedshiftStorage", "RelationalFilterConfigurations" ], + "required" : [ "RelationalFilterConfigurations" ], "additionalProperties" : false }, "RedshiftServerlessStorage" : { @@ -348,6 +354,14 @@ "minItems" : 0, "insertionOrder" : false }, + "ConnectionId" : { + "type" : "string", + "description" : "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run" + }, + "ConnectionIdentifier" : { + "type" : "string", + "description" : "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run" + }, "CreatedAt" : { "type" : "string", "description" : "The timestamp of when the data source was created.", @@ -374,8 +388,7 @@ }, "EnvironmentId" : { "type" : "string", - "description" : "The unique identifier of the Amazon DataZone environment to which the data source publishes assets.", - "pattern" : "^[a-zA-Z0-9_-]{1,36}$" + "description" : "The unique identifier of the Amazon DataZone environment to which the data source publishes assets." }, "EnvironmentIdentifier" : { "description" : "The unique identifier of the Amazon DataZone environment to which the data source publishes assets.", @@ -445,10 +458,10 @@ "format" : "date-time" } }, - "required" : [ "Name", "DomainIdentifier", "ProjectIdentifier", "EnvironmentIdentifier", "Type" ], - "readOnlyProperties" : [ "/properties/CreatedAt", "/properties/DomainId", "/properties/EnvironmentId", "/properties/Id", "/properties/LastRunAssetCount", "/properties/LastRunAt", "/properties/LastRunStatus", "/properties/ProjectId", "/properties/Status", "/properties/UpdatedAt" ], - "writeOnlyProperties" : [ "/properties/AssetFormsInput", "/properties/EnvironmentIdentifier", "/properties/DomainIdentifier", "/properties/Configuration", "/properties/ProjectIdentifier" ], - "createOnlyProperties" : [ "/properties/EnvironmentIdentifier", "/properties/DomainIdentifier", "/properties/ProjectIdentifier", "/properties/Type" ], + "required" : [ "Name", "DomainIdentifier", "ProjectIdentifier", "Type" ], + "readOnlyProperties" : [ "/properties/ConnectionId", "/properties/CreatedAt", "/properties/DomainId", "/properties/EnvironmentId", "/properties/Id", "/properties/LastRunAssetCount", "/properties/LastRunAt", "/properties/LastRunStatus", "/properties/ProjectId", "/properties/Status", "/properties/UpdatedAt" ], + "writeOnlyProperties" : [ "/properties/AssetFormsInput", "/properties/ConnectionIdentifier", "/properties/EnvironmentIdentifier", "/properties/DomainIdentifier", "/properties/Configuration", "/properties/ProjectIdentifier" ], + "createOnlyProperties" : [ "/properties/ConnectionIdentifier", "/properties/EnvironmentIdentifier", "/properties/DomainIdentifier", "/properties/ProjectIdentifier", "/properties/Type" ], "primaryIdentifier" : [ "/properties/DomainId", "/properties/Id" ], "tagging" : { "taggable" : false, diff --git a/aws-cloudformation-schema/aws-detective-graph.json b/aws-cloudformation-schema/aws-detective-graph.json index 70b69ad8cb..f57a03df86 100644 --- a/aws-cloudformation-schema/aws-detective-graph.json +++ b/aws-cloudformation-schema/aws-detective-graph.json @@ -43,6 +43,14 @@ "additionalProperties" : false, "readOnlyProperties" : [ "/properties/Arn" ], "primaryIdentifier" : [ "/properties/Arn" ], + "tagging" : { + "taggable" : true, + "tagOnCreate" : true, + "tagUpdatable" : true, + "cloudFormationSystemTags" : true, + "tagProperty" : "/properties/Tags", + "permissions" : [ "detective:UntagResource", "detective:TagResource", "detective:ListTagsForResource" ] + }, "handlers" : { "create" : { "permissions" : [ "detective:CreateGraph", "detective:UpdateOrganizationConfiguration", "organizations:DescribeOrganization" ] diff --git a/aws-cloudformation-schema/aws-detective-memberinvitation.json b/aws-cloudformation-schema/aws-detective-memberinvitation.json index edb766e635..27b0752d94 100644 --- a/aws-cloudformation-schema/aws-detective-memberinvitation.json +++ b/aws-cloudformation-schema/aws-detective-memberinvitation.json @@ -35,6 +35,9 @@ "primaryIdentifier" : [ "/properties/GraphArn", "/properties/MemberId" ], "createOnlyProperties" : [ "/properties/GraphArn", "/properties/MemberId" ], "writeOnlyProperties" : [ "/properties/Message", "/properties/DisableEmailNotification" ], + "tagging" : { + "taggable" : false + }, "handlers" : { "create" : { "permissions" : [ "detective:CreateMembers", "detective:GetMembers" ] diff --git a/aws-cloudformation-schema/aws-iot-thingtype.json b/aws-cloudformation-schema/aws-iot-thingtype.json index 2b7c3d32e9..ea0952d92f 100644 --- a/aws-cloudformation-schema/aws-iot-thingtype.json +++ b/aws-cloudformation-schema/aws-iot-thingtype.json @@ -72,14 +72,14 @@ "properties" : { "Key" : { "type" : "string", - "description" : "The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. ", + "description" : "Tag key (1-128 chars). No 'aws:' prefix. Allows: [A-Za-z0-9 _.:/=+-]", "minLength" : 1, "maxLength" : 128, "pattern" : "^([\\p{L}\\p{Z}\\p{N}_.:/=+\\-@]*)$" }, "Value" : { "type" : "string", - "description" : "The value for the tag. You can specify a value that is 1 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. ", + "description" : "Tag value (1-256 chars). No 'aws:' prefix. Allows: [A-Za-z0-9 _.:/=+-]", "minLength" : 1, "maxLength" : 256 } diff --git a/aws-cloudformation-schema/aws-notificationscontacts-emailcontact.json b/aws-cloudformation-schema/aws-notificationscontacts-emailcontact.json new file mode 100644 index 0000000000..2b2fedc825 --- /dev/null +++ b/aws-cloudformation-schema/aws-notificationscontacts-emailcontact.json @@ -0,0 +1,122 @@ +{ + "typeName" : "AWS::NotificationsContacts::EmailContact", + "description" : "Definition of AWS::NotificationsContacts::EmailContact Resource Type", + "definitions" : { + "EmailContact" : { + "type" : "object", + "properties" : { + "Arn" : { + "type" : "string", + "pattern" : "^arn:aws:notifications-contacts::[0-9]{12}:emailcontact/[a-z0-9]{27}$" + }, + "Name" : { + "type" : "string", + "maxLength" : 64, + "minLength" : 1, + "pattern" : "[\\w-.~]+" + }, + "Address" : { + "type" : "string", + "maxLength" : 254, + "minLength" : 6, + "pattern" : "^(.+)@(.+)$" + }, + "Status" : { + "$ref" : "#/definitions/EmailContactStatus" + }, + "CreationTime" : { + "type" : "string", + "format" : "date-time" + }, + "UpdateTime" : { + "type" : "string", + "format" : "date-time" + } + }, + "required" : [ "Address", "Arn", "CreationTime", "Name", "Status", "UpdateTime" ], + "additionalProperties" : false + }, + "EmailContactStatus" : { + "type" : "string", + "enum" : [ "inactive", "active" ] + }, + "TagMap" : { + "description" : "A list of tags that are attached to the role.", + "type" : "array", + "uniqueItems" : false, + "insertionOrder" : false, + "items" : { + "$ref" : "#/definitions/Tag" + } + }, + "Tag" : { + "type" : "object", + "additionalProperties" : false, + "properties" : { + "Key" : { + "type" : "string", + "minLength" : 1, + "maxLength" : 128 + }, + "Value" : { + "type" : "string", + "minLength" : 0, + "maxLength" : 256 + } + }, + "required" : [ "Key", "Value" ] + } + }, + "properties" : { + "Arn" : { + "type" : "string", + "pattern" : "^arn:aws:notifications-contacts::[0-9]{12}:emailcontact/[a-z0-9]{27}$" + }, + "EmailAddress" : { + "type" : "string", + "maxLength" : 254, + "minLength" : 6, + "pattern" : "^(.+)@(.+)$" + }, + "Name" : { + "type" : "string", + "maxLength" : 64, + "minLength" : 1, + "pattern" : "[\\w-.~]+" + }, + "EmailContact" : { + "$ref" : "#/definitions/EmailContact" + }, + "Tags" : { + "$ref" : "#/definitions/TagMap" + } + }, + "required" : [ "EmailAddress", "Name" ], + "readOnlyProperties" : [ "/properties/Arn", "/properties/EmailContact", "/properties/EmailContact/Arn", "/properties/EmailContact/Address", "/properties/EmailContact/Name", "/properties/EmailContact/Status", "/properties/EmailContact/CreationTime", "/properties/EmailContact/UpdateTime" ], + "writeOnlyProperties" : [ "/properties/EmailAddress", "/properties/Name" ], + "createOnlyProperties" : [ "/properties/EmailAddress", "/properties/Name", "/properties/Tags" ], + "primaryIdentifier" : [ "/properties/Arn" ], + "handlers" : { + "create" : { + "permissions" : [ "notifications-contacts:CreateEmailContact", "notifications-contacts:GetEmailContact", "notifications-contacts:TagResource", "notifications-contacts:UntagResource", "notifications-contacts:ListTagsForResource" ] + }, + "read" : { + "permissions" : [ "notifications-contacts:GetEmailContact", "notifications-contacts:ListTagsForResource", "notifications-contacts:TagResource" ] + }, + "delete" : { + "permissions" : [ "notifications-contacts:DeleteEmailContact", "notifications-contacts:GetEmailContact" ] + }, + "list" : { + "permissions" : [ "notifications-contacts:ListEmailContacts" ] + } + }, + "tagging" : { + "taggable" : true, + "tagOnCreate" : true, + "tagUpdatable" : false, + "cloudFormationSystemTags" : true, + "tagProperty" : "/properties/Tags", + "permissions" : [ "notifications-contacts:TagResource", "notifications-contacts:UntagResource", "notifications-contacts:ListTagsForResource" ] + }, + "additionalProperties" : false +} \ No newline at end of file diff --git a/aws-cloudformation-schema/aws-sns-topic.json b/aws-cloudformation-schema/aws-sns-topic.json index 67ca3e5d18..92d7be5508 100644 --- a/aws-cloudformation-schema/aws-sns-topic.json +++ b/aws-cloudformation-schema/aws-sns-topic.json @@ -37,6 +37,10 @@ "description" : "The archive policy determines the number of days SNS retains messages. You can set a retention period from 1 to 365 days.", "type" : "object" }, + "FifoThroughputScope" : { + "description" : "", + "type" : "string" + }, "Tags" : { "type" : "array", "uniqueItems" : false, diff --git a/aws-cloudformation-schema/aws-workspaces-connectionalias.json b/aws-cloudformation-schema/aws-workspaces-connectionalias.json index 68c63ed9f7..aba8eb905a 100644 --- a/aws-cloudformation-schema/aws-workspaces-connectionalias.json +++ b/aws-cloudformation-schema/aws-workspaces-connectionalias.json @@ -46,6 +46,7 @@ "type" : "array", "maxLength" : 25, "minLength" : 1, + "insertionOrder" : false, "items" : { "$ref" : "#/definitions/ConnectionAliasAssociation" } @@ -69,6 +70,7 @@ "Tags" : { "type" : "array", "uniqueItems" : false, + "insertionOrder" : false, "items" : { "$ref" : "#/definitions/Tag" } @@ -81,13 +83,13 @@ "readOnlyProperties" : [ "/properties/ConnectionAliasState", "/properties/AliasId", "/properties/Associations" ], "handlers" : { "create" : { - "permissions" : [ "workspaces:CreateConnectionAlias" ] + "permissions" : [ "workspaces:CreateConnectionAlias", "workspaces:CreateTags", "workspaces:DescribeConnectionAliases", "workspaces:DescribeTags" ] }, "read" : { - "permissions" : [ "workspaces:DescribeConnectionAliases" ] + "permissions" : [ "workspaces:DescribeConnectionAliases", "workspaces:DescribeTags" ] }, "delete" : { - "permissions" : [ "workspaces:DeleteConnectionAlias" ] + "permissions" : [ "workspaces:DeleteConnectionAlias", "workspaces:DeleteTags", "workspaces:DescribeTags", "workspaces:DescribeConnectionAliases" ] } } } \ No newline at end of file diff --git a/meta/.botocore.version b/meta/.botocore.version index 64ab418437..6e8a789ad0 100644 --- a/meta/.botocore.version +++ b/meta/.botocore.version @@ -1 +1 @@ -1.35.98 +1.35.99 diff --git a/meta/regions.json b/meta/regions.json index 209909baea..0e34f04555 100644 --- a/meta/regions.json +++ b/meta/regions.json @@ -103,6 +103,10 @@ "name": "me-south-1", "description": "Middle East (Bahrain)" }, + { + "name": "mx-central-1", + "description": "Mexico (Central)" + }, { "name": "sa-east-1", "description": "South America (Sao Paulo)" diff --git a/provider/cmd/pulumi-resource-aws-native/metadata.json b/provider/cmd/pulumi-resource-aws-native/metadata.json index 8d23921d58..6519a7e676 100644 --- a/provider/cmd/pulumi-resource-aws-native/metadata.json +++ b/provider/cmd/pulumi-resource-aws-native/metadata.json @@ -13700,8 +13700,7 @@ }, "knowledgeBaseConfiguration": { "$ref": "#/types/aws-native:bedrock:KnowledgeBaseConfiguration", - "description": "Contains details about the embeddings configuration of the knowledge base.", - "replaceOnChanges": true + "description": "Contains details about the embeddings configuration of the knowledge base." }, "knowledgeBaseId": { "type": "string", @@ -13744,7 +13743,12 @@ "roleArn" ], "createOnly": [ - "knowledgeBaseConfiguration", + "knowledgeBaseConfiguration/kendraKnowledgeBaseConfiguration", + "knowledgeBaseConfiguration/sqlKnowledgeBaseConfiguration/redshiftConfiguration/queryEngineConfiguration", + "knowledgeBaseConfiguration/sqlKnowledgeBaseConfiguration/redshiftConfiguration/storageConfigurations", + "knowledgeBaseConfiguration/sqlKnowledgeBaseConfiguration/type", + "knowledgeBaseConfiguration/type", + "knowledgeBaseConfiguration/vectorKnowledgeBaseConfiguration", "storageConfiguration" ], "readOnly": [ @@ -29104,6 +29108,10 @@ ], "description": "Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration." }, + "connectionIdentifier": { + "type": "string", + "description": "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run" + }, "description": { "type": "string", "description": "The description of the data source." @@ -29171,6 +29179,15 @@ ], "description": "Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration." }, + "connectionId": { + "type": "string", + "description": "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run" + }, + "connectionIdentifier": { + "type": "string", + "description": "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run", + "replaceOnChanges": true + }, "createdAt": { "type": "string", "description": "The timestamp of when the data source was created." @@ -29259,17 +29276,18 @@ }, "required": [ "domainIdentifier", - "environmentIdentifier", "projectIdentifier", "type" ], "createOnly": [ + "connectionIdentifier", "domainIdentifier", "environmentIdentifier", "projectIdentifier", "type" ], "readOnly": [ + "connectionId", "createdAt", "domainId", "environmentId", @@ -29284,6 +29302,7 @@ "writeOnly": [ "assetFormsInput", "configuration", + "connectionIdentifier", "domainIdentifier", "environmentIdentifier", "projectIdentifier" @@ -88520,7 +88539,7 @@ }, "databaseInsightsMode": { "type": "string", - "description": "The mode of Database Insights to enable for the DB instance.\n\nThis setting only applies to Amazon Aurora DB instances.\n\n\u003e Currently, this value is inherited from the DB cluster and can't be changed." + "description": "The mode of Database Insights that is enabled for the instance." }, "dbClusterIdentifier": { "type": "string", @@ -104033,6 +104052,9 @@ "type": "string", "description": "The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs." }, + "fifoThroughputScope": { + "type": "string" + }, "fifoTopic": { "type": "boolean", "description": "Set to true to create a FIFO topic." @@ -104092,6 +104114,9 @@ "type": "string", "description": "The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs." }, + "fifoThroughputScope": { + "type": "string" + }, "fifoTopic": { "type": "boolean", "description": "Set to true to create a FIFO topic.", @@ -104463,7 +104488,7 @@ }, "automationTargetParameterName": { "type": "string", - "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager ." + "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager ." }, "calendarNames": { "type": "array", @@ -104549,7 +104574,7 @@ }, "automationTargetParameterName": { "type": "string", - "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager ." + "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager ." }, "calendarNames": { "type": "array", @@ -127031,15 +127056,32 @@ "properties": { "kendraKnowledgeBaseConfiguration": { "$ref": "#/types/aws-native:bedrock:KnowledgeBaseKendraKnowledgeBaseConfiguration", - "description": "Settings for an Amazon Kendra knowledge base." + "description": "Settings for an Amazon Kendra knowledge base.", + "replaceOnChanges": true + }, + "sqlKnowledgeBaseConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseSqlKnowledgeBaseConfiguration" }, "type": { "$ref": "#/types/aws-native:bedrock:KnowledgeBaseType", - "description": "The type of data that the data source is converted into for the knowledge base." + "description": "The type of data that the data source is converted into for the knowledge base.", + "replaceOnChanges": true }, "vectorKnowledgeBaseConfiguration": { "$ref": "#/types/aws-native:bedrock:KnowledgeBaseVectorKnowledgeBaseConfiguration", - "description": "Contains details about the model that's used to convert the data source into vector embeddings." + "description": "Contains details about the model that's used to convert the data source into vector embeddings.", + "replaceOnChanges": true + } + } + }, + "aws-native:bedrock:KnowledgeBaseCuratedQuery": { + "type": "object", + "properties": { + "naturalLanguage": { + "type": "string" + }, + "sql": { + "type": "string" } } }, @@ -127052,6 +127094,9 @@ } } }, + "aws-native:bedrock:KnowledgeBaseInclusionType": { + "type": "string" + }, "aws-native:bedrock:KnowledgeBaseKendraKnowledgeBaseConfiguration": { "type": "object", "properties": { @@ -127179,6 +127224,71 @@ } } }, + "aws-native:bedrock:KnowledgeBaseQueryEngineType": { + "type": "string" + }, + "aws-native:bedrock:KnowledgeBaseQueryGenerationColumn": { + "type": "object", + "properties": { + "description": { + "type": "string" + }, + "inclusion": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseInclusionType" + }, + "name": { + "type": "string" + } + } + }, + "aws-native:bedrock:KnowledgeBaseQueryGenerationConfiguration": { + "type": "object", + "properties": { + "executionTimeoutSeconds": { + "type": "integer" + }, + "generationContext": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryGenerationContext" + } + } + }, + "aws-native:bedrock:KnowledgeBaseQueryGenerationContext": { + "type": "object", + "properties": { + "curatedQueries": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseCuratedQuery" + } + }, + "tables": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryGenerationTable" + } + } + } + }, + "aws-native:bedrock:KnowledgeBaseQueryGenerationTable": { + "type": "object", + "properties": { + "columns": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryGenerationColumn" + } + }, + "description": { + "type": "string" + }, + "inclusion": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseInclusionType" + }, + "name": { + "type": "string" + } + } + }, "aws-native:bedrock:KnowledgeBaseRdsConfiguration": { "type": "object", "properties": { @@ -127225,6 +127335,132 @@ } } }, + "aws-native:bedrock:KnowledgeBaseRedshiftConfiguration": { + "type": "object", + "properties": { + "queryEngineConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineConfiguration", + "replaceOnChanges": true + }, + "queryGenerationConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryGenerationConfiguration" + }, + "storageConfigurations": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineStorageConfiguration" + }, + "replaceOnChanges": true + } + } + }, + "aws-native:bedrock:KnowledgeBaseRedshiftProvisionedAuthConfiguration": { + "type": "object", + "properties": { + "databaseUser": { + "type": "string", + "description": "Redshift database user" + }, + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftProvisionedAuthType" + }, + "usernamePasswordSecretArn": { + "type": "string" + } + } + }, + "aws-native:bedrock:KnowledgeBaseRedshiftProvisionedAuthType": { + "type": "string" + }, + "aws-native:bedrock:KnowledgeBaseRedshiftProvisionedConfiguration": { + "type": "object", + "properties": { + "authConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftProvisionedAuthConfiguration" + }, + "clusterIdentifier": { + "type": "string" + } + } + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration": { + "type": "object", + "properties": { + "tableNames": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineConfiguration": { + "type": "object", + "properties": { + "provisionedConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftProvisionedConfiguration" + }, + "serverlessConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftServerlessConfiguration" + }, + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineType" + } + } + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration": { + "type": "object", + "properties": { + "databaseName": { + "type": "string" + } + } + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineStorageConfiguration": { + "type": "object", + "properties": { + "awsDataCatalogConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration" + }, + "redshiftConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration" + }, + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineStorageType" + } + } + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineStorageType": { + "type": "string" + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineType": { + "type": "string" + }, + "aws-native:bedrock:KnowledgeBaseRedshiftServerlessAuthConfiguration": { + "type": "object", + "properties": { + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftServerlessAuthType" + }, + "usernamePasswordSecretArn": { + "type": "string" + } + } + }, + "aws-native:bedrock:KnowledgeBaseRedshiftServerlessAuthType": { + "type": "string" + }, + "aws-native:bedrock:KnowledgeBaseRedshiftServerlessConfiguration": { + "type": "object", + "properties": { + "authConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftServerlessAuthConfiguration" + }, + "workgroupArn": { + "type": "string" + } + } + }, "aws-native:bedrock:KnowledgeBaseS3Location": { "type": "object", "properties": { @@ -127237,6 +127473,18 @@ "uri": "URI" } }, + "aws-native:bedrock:KnowledgeBaseSqlKnowledgeBaseConfiguration": { + "type": "object", + "properties": { + "redshiftConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftConfiguration" + }, + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryEngineType", + "replaceOnChanges": true + } + } + }, "aws-native:bedrock:KnowledgeBaseStatus": { "type": "string" }, @@ -139690,6 +139938,10 @@ "type": "boolean", "description": "Specifies whether to automatically import data quality metrics as part of the data source run." }, + "catalogName": { + "type": "string", + "description": "The catalog name in the AWS Glue run configuration." + }, "dataAccessRole": { "type": "string", "description": "The data access role included in the configuration details of the AWS Glue data source." @@ -159663,11 +159915,11 @@ "properties": { "key": { "type": "string", - "description": "The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. " + "description": "Tag key (1-128 chars). No 'aws:' prefix. Allows: [A-Za-z0-9 _.:/=+-]" }, "value": { "type": "string", - "description": "The value for the tag. You can specify a value that is 1 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. " + "description": "Tag value (1-256 chars). No 'aws:' prefix. Allows: [A-Za-z0-9 _.:/=+-]" } } }, diff --git a/provider/cmd/pulumi-resource-aws-native/schema.json b/provider/cmd/pulumi-resource-aws-native/schema.json index f69c3d5b13..97f42ef7c1 100644 --- a/provider/cmd/pulumi-resource-aws-native/schema.json +++ b/provider/cmd/pulumi-resource-aws-native/schema.json @@ -19676,6 +19676,10 @@ { "name": "Custom", "value": "CUSTOM" + }, + { + "name": "RedshiftMetadata", + "value": "REDSHIFT_METADATA" } ] }, @@ -22159,15 +22163,21 @@ "properties": { "kendraKnowledgeBaseConfiguration": { "$ref": "#/types/aws-native:bedrock:KnowledgeBaseKendraKnowledgeBaseConfiguration", - "description": "Settings for an Amazon Kendra knowledge base." + "description": "Settings for an Amazon Kendra knowledge base.", + "replaceOnChanges": true + }, + "sqlKnowledgeBaseConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseSqlKnowledgeBaseConfiguration" }, "type": { "$ref": "#/types/aws-native:bedrock:KnowledgeBaseType", - "description": "The type of data that the data source is converted into for the knowledge base." + "description": "The type of data that the data source is converted into for the knowledge base.", + "replaceOnChanges": true }, "vectorKnowledgeBaseConfiguration": { "$ref": "#/types/aws-native:bedrock:KnowledgeBaseVectorKnowledgeBaseConfiguration", - "description": "Contains details about the model that's used to convert the data source into vector embeddings." + "description": "Contains details about the model that's used to convert the data source into vector embeddings.", + "replaceOnChanges": true } }, "type": "object", @@ -22175,6 +22185,22 @@ "type" ] }, + "aws-native:bedrock:KnowledgeBaseCuratedQuery": { + "description": "Curated query or question and answer pair", + "properties": { + "naturalLanguage": { + "type": "string" + }, + "sql": { + "type": "string" + } + }, + "type": "object", + "required": [ + "naturalLanguage", + "sql" + ] + }, "aws-native:bedrock:KnowledgeBaseEmbeddingModelConfiguration": { "description": "The embeddings model configuration details for the vector model used in Knowledge Base.", "properties": { @@ -22185,6 +22211,20 @@ }, "type": "object" }, + "aws-native:bedrock:KnowledgeBaseInclusionType": { + "description": "Include or Exclude status for an entity", + "type": "string", + "enum": [ + { + "name": "Include", + "value": "INCLUDE" + }, + { + "name": "Exclude", + "value": "EXCLUDE" + } + ] + }, "aws-native:bedrock:KnowledgeBaseKendraKnowledgeBaseConfiguration": { "description": "Configurations for a Kendra knowledge base", "properties": { @@ -22354,6 +22394,85 @@ "textField" ] }, + "aws-native:bedrock:KnowledgeBaseQueryEngineType": { + "description": "SQL query engine type", + "type": "string", + "enum": [ + { + "name": "Redshift", + "value": "REDSHIFT" + } + ] + }, + "aws-native:bedrock:KnowledgeBaseQueryGenerationColumn": { + "description": "Redshift query generation column", + "properties": { + "description": { + "type": "string" + }, + "inclusion": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseInclusionType" + }, + "name": { + "type": "string" + } + }, + "type": "object" + }, + "aws-native:bedrock:KnowledgeBaseQueryGenerationConfiguration": { + "description": "Configurations for generating Redshift engine queries", + "properties": { + "executionTimeoutSeconds": { + "type": "integer" + }, + "generationContext": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryGenerationContext" + } + }, + "type": "object" + }, + "aws-native:bedrock:KnowledgeBaseQueryGenerationContext": { + "description": "Context used to improve query generation", + "properties": { + "curatedQueries": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseCuratedQuery" + } + }, + "tables": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryGenerationTable" + } + } + }, + "type": "object" + }, + "aws-native:bedrock:KnowledgeBaseQueryGenerationTable": { + "description": "Tables used for Redshift query generation context", + "properties": { + "columns": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryGenerationColumn" + } + }, + "description": { + "type": "string" + }, + "inclusion": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseInclusionType" + }, + "name": { + "type": "string" + } + }, + "type": "object", + "required": [ + "name" + ] + }, "aws-native:bedrock:KnowledgeBaseRdsConfiguration": { "description": "Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS.", "properties": { @@ -22415,6 +22534,219 @@ "vectorField" ] }, + "aws-native:bedrock:KnowledgeBaseRedshiftConfiguration": { + "description": "Configurations for a Redshift knowledge base", + "properties": { + "queryEngineConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineConfiguration", + "replaceOnChanges": true + }, + "queryGenerationConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryGenerationConfiguration" + }, + "storageConfigurations": { + "type": "array", + "items": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineStorageConfiguration" + }, + "replaceOnChanges": true + } + }, + "type": "object", + "required": [ + "queryEngineConfiguration", + "storageConfigurations" + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftProvisionedAuthConfiguration": { + "description": "Configurations for Redshift query engine provisioned auth setup", + "properties": { + "databaseUser": { + "type": "string", + "description": "Redshift database user" + }, + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftProvisionedAuthType" + }, + "usernamePasswordSecretArn": { + "type": "string" + } + }, + "type": "object", + "required": [ + "type" + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftProvisionedAuthType": { + "description": "Provisioned Redshift auth type", + "type": "string", + "enum": [ + { + "name": "Iam", + "value": "IAM" + }, + { + "name": "UsernamePassword", + "value": "USERNAME_PASSWORD" + }, + { + "name": "Username", + "value": "USERNAME" + } + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftProvisionedConfiguration": { + "description": "Configurations for provisioned Redshift query engine", + "properties": { + "authConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftProvisionedAuthConfiguration" + }, + "clusterIdentifier": { + "type": "string" + } + }, + "type": "object", + "required": [ + "authConfiguration", + "clusterIdentifier" + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration": { + "description": "Configurations for Redshift query engine AWS Data Catalog backed storage", + "properties": { + "tableNames": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "type": "object", + "required": [ + "tableNames" + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineConfiguration": { + "description": "Configurations for Redshift query engine", + "properties": { + "provisionedConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftProvisionedConfiguration" + }, + "serverlessConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftServerlessConfiguration" + }, + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineType" + } + }, + "type": "object", + "required": [ + "type" + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration": { + "description": "Configurations for Redshift query engine Redshift backed storage", + "properties": { + "databaseName": { + "type": "string" + } + }, + "type": "object", + "required": [ + "databaseName" + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineStorageConfiguration": { + "description": "Configurations for available Redshift query engine storage types", + "properties": { + "awsDataCatalogConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration" + }, + "redshiftConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration" + }, + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineStorageType" + } + }, + "type": "object", + "required": [ + "type" + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineStorageType": { + "description": "Redshift query engine storage type", + "type": "string", + "enum": [ + { + "name": "Redshift", + "value": "REDSHIFT" + }, + { + "name": "AwsDataCatalog", + "value": "AWS_DATA_CATALOG" + } + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftQueryEngineType": { + "description": "Redshift query engine type", + "type": "string", + "enum": [ + { + "name": "Serverless", + "value": "SERVERLESS" + }, + { + "name": "Provisioned", + "value": "PROVISIONED" + } + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftServerlessAuthConfiguration": { + "description": "Configurations for Redshift query engine serverless auth setup", + "properties": { + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftServerlessAuthType" + }, + "usernamePasswordSecretArn": { + "type": "string" + } + }, + "type": "object", + "required": [ + "type" + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftServerlessAuthType": { + "description": "Serverless Redshift auth type", + "type": "string", + "enum": [ + { + "name": "Iam", + "value": "IAM" + }, + { + "name": "UsernamePassword", + "value": "USERNAME_PASSWORD" + } + ] + }, + "aws-native:bedrock:KnowledgeBaseRedshiftServerlessConfiguration": { + "description": "Configurations for serverless Redshift query engine", + "properties": { + "authConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftServerlessAuthConfiguration" + }, + "workgroupArn": { + "type": "string" + } + }, + "type": "object", + "required": [ + "authConfiguration", + "workgroupArn" + ] + }, "aws-native:bedrock:KnowledgeBaseS3Location": { "description": "An Amazon S3 location.", "properties": { @@ -22428,6 +22760,22 @@ "uri" ] }, + "aws-native:bedrock:KnowledgeBaseSqlKnowledgeBaseConfiguration": { + "description": "Configurations for a SQL knowledge base", + "properties": { + "redshiftConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseRedshiftConfiguration" + }, + "type": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseQueryEngineType", + "replaceOnChanges": true + } + }, + "type": "object", + "required": [ + "type" + ] + }, "aws-native:bedrock:KnowledgeBaseStatus": { "description": "The status of a knowledge base.", "type": "string", @@ -22560,6 +22908,10 @@ { "name": "Kendra", "value": "KENDRA" + }, + { + "name": "Sql", + "value": "SQL" } ] }, @@ -41710,6 +42062,10 @@ "type": "boolean", "description": "Specifies whether to automatically import data quality metrics as part of the data source run." }, + "catalogName": { + "type": "string", + "description": "The catalog name in the AWS Glue run configuration." + }, "dataAccessRole": { "type": "string", "description": "The data access role included in the configuration details of the AWS Glue data source." @@ -41794,8 +42150,6 @@ }, "type": "object", "required": [ - "redshiftCredentialConfiguration", - "redshiftStorage", "relationalFilterConfigurations" ] }, @@ -67528,6 +67882,11 @@ "description": "Middle East (Bahrain)", "value": "me-south-1" }, + { + "name": "MxCentral1", + "description": "Mexico (Central)", + "value": "mx-central-1" + }, { "name": "SaEast1", "description": "South America (Sao Paulo)", @@ -70453,11 +70812,11 @@ "properties": { "key": { "type": "string", - "description": "The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. " + "description": "Tag key (1-128 chars). No 'aws:' prefix. Allows: [A-Za-z0-9 _.:/=+-]" }, "value": { "type": "string", - "description": "The value for the tag. You can specify a value that is 1 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. " + "description": "Tag value (1-256 chars). No 'aws:' prefix. Allows: [A-Za-z0-9 _.:/=+-]" } }, "type": "object", @@ -194366,8 +194725,7 @@ }, "knowledgeBaseConfiguration": { "$ref": "#/types/aws-native:bedrock:KnowledgeBaseConfiguration", - "description": "Contains details about the embeddings configuration of the knowledge base.", - "replaceOnChanges": true + "description": "Contains details about the embeddings configuration of the knowledge base." }, "knowledgeBaseId": { "type": "string", @@ -208257,6 +208615,15 @@ ], "description": "Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration." }, + "connectionId": { + "type": "string", + "description": "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run" + }, + "connectionIdentifier": { + "type": "string", + "description": "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run", + "replaceOnChanges": true + }, "createdAt": { "type": "string", "description": "The timestamp of when the data source was created." @@ -208341,11 +208708,11 @@ "type": "object", "required": [ "awsId", + "connectionId", "createdAt", "domainId", "domainIdentifier", "environmentId", - "environmentIdentifier", "lastRunAssetCount", "lastRunAt", "lastRunStatus", @@ -208378,6 +208745,10 @@ ], "description": "Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration." }, + "connectionIdentifier": { + "type": "string", + "description": "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run" + }, "description": { "type": "string", "description": "The description of the data source." @@ -208421,7 +208792,6 @@ }, "requiredInputs": [ "domainIdentifier", - "environmentIdentifier", "projectIdentifier", "type" ] @@ -260724,7 +261094,7 @@ }, "databaseInsightsMode": { "type": "string", - "description": "The mode of Database Insights to enable for the DB instance.\n\nThis setting only applies to Amazon Aurora DB instances.\n\n\u003e Currently, this value is inherited from the DB cluster and can't be changed." + "description": "The mode of Database Insights that is enabled for the instance." }, "dbClusterIdentifier": { "type": "string", @@ -274578,6 +274948,9 @@ "type": "string", "description": "The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs." }, + "fifoThroughputScope": { + "type": "string" + }, "fifoTopic": { "type": "boolean", "description": "Set to true to create a FIFO topic.", @@ -274647,6 +275020,9 @@ "type": "string", "description": "The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs." }, + "fifoThroughputScope": { + "type": "string" + }, "fifoTopic": { "type": "boolean", "description": "Set to true to create a FIFO topic." @@ -274965,7 +275341,7 @@ }, "automationTargetParameterName": { "type": "string", - "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager ." + "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager ." }, "calendarNames": { "type": "array", @@ -275052,7 +275428,7 @@ }, "automationTargetParameterName": { "type": "string", - "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager ." + "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager ." }, "calendarNames": { "type": "array", @@ -289175,6 +289551,10 @@ "type": "string", "description": "The ARN of the knowledge base." }, + "knowledgeBaseConfiguration": { + "$ref": "#/types/aws-native:bedrock:KnowledgeBaseConfiguration", + "description": "Contains details about the embeddings configuration of the knowledge base." + }, "knowledgeBaseId": { "type": "string", "description": "The unique identifier of the knowledge base." @@ -296556,6 +296936,10 @@ }, "outputs": { "properties": { + "connectionId": { + "type": "string", + "description": "The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run" + }, "createdAt": { "type": "string", "description": "The timestamp of when the data source was created." @@ -323724,7 +324108,7 @@ }, "databaseInsightsMode": { "type": "string", - "description": "The mode of Database Insights to enable for the DB instance.\n\nThis setting only applies to Amazon Aurora DB instances.\n\n\u003e Currently, this value is inherited from the DB cluster and can't be changed." + "description": "The mode of Database Insights that is enabled for the instance." }, "dbClusterSnapshotIdentifier": { "type": "string", @@ -330947,6 +331331,9 @@ "type": "string", "description": "The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs." }, + "fifoThroughputScope": { + "type": "string" + }, "kmsMasterKeyId": { "type": "string", "description": "The ID of an AWS managed customer master key (CMK) for SNS or a custom CMK. For more information, see [Key terms](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms). For more examples, see ``KeyId`` in the *API Reference*.\n This property applies only to [server-side-encryption](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html)." @@ -331171,7 +331558,7 @@ }, "automationTargetParameterName": { "type": "string", - "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager ." + "description": "Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager ." }, "calendarNames": { "type": "array", diff --git a/sdk/dotnet/Bedrock/Enums.cs b/sdk/dotnet/Bedrock/Enums.cs index 79746cbafa..a59c1a0cd9 100644 --- a/sdk/dotnet/Bedrock/Enums.cs +++ b/sdk/dotnet/Bedrock/Enums.cs @@ -809,6 +809,7 @@ private DataSourceType(string value) public static DataSourceType Sharepoint { get; } = new DataSourceType("SHAREPOINT"); public static DataSourceType Web { get; } = new DataSourceType("WEB"); public static DataSourceType Custom { get; } = new DataSourceType("CUSTOM"); + public static DataSourceType RedshiftMetadata { get; } = new DataSourceType("REDSHIFT_METADATA"); public static bool operator ==(DataSourceType left, DataSourceType right) => left.Equals(right); public static bool operator !=(DataSourceType left, DataSourceType right) => !left.Equals(right); @@ -1479,6 +1480,192 @@ private GuardrailTopicType(string value) public override string ToString() => _value; } + /// + /// Include or Exclude status for an entity + /// + [EnumType] + public readonly struct KnowledgeBaseInclusionType : IEquatable + { + private readonly string _value; + + private KnowledgeBaseInclusionType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static KnowledgeBaseInclusionType Include { get; } = new KnowledgeBaseInclusionType("INCLUDE"); + public static KnowledgeBaseInclusionType Exclude { get; } = new KnowledgeBaseInclusionType("EXCLUDE"); + + public static bool operator ==(KnowledgeBaseInclusionType left, KnowledgeBaseInclusionType right) => left.Equals(right); + public static bool operator !=(KnowledgeBaseInclusionType left, KnowledgeBaseInclusionType right) => !left.Equals(right); + + public static explicit operator string(KnowledgeBaseInclusionType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is KnowledgeBaseInclusionType other && Equals(other); + public bool Equals(KnowledgeBaseInclusionType other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + + /// + /// SQL query engine type + /// + [EnumType] + public readonly struct KnowledgeBaseQueryEngineType : IEquatable + { + private readonly string _value; + + private KnowledgeBaseQueryEngineType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static KnowledgeBaseQueryEngineType Redshift { get; } = new KnowledgeBaseQueryEngineType("REDSHIFT"); + + public static bool operator ==(KnowledgeBaseQueryEngineType left, KnowledgeBaseQueryEngineType right) => left.Equals(right); + public static bool operator !=(KnowledgeBaseQueryEngineType left, KnowledgeBaseQueryEngineType right) => !left.Equals(right); + + public static explicit operator string(KnowledgeBaseQueryEngineType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is KnowledgeBaseQueryEngineType other && Equals(other); + public bool Equals(KnowledgeBaseQueryEngineType other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + + /// + /// Provisioned Redshift auth type + /// + [EnumType] + public readonly struct KnowledgeBaseRedshiftProvisionedAuthType : IEquatable + { + private readonly string _value; + + private KnowledgeBaseRedshiftProvisionedAuthType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static KnowledgeBaseRedshiftProvisionedAuthType Iam { get; } = new KnowledgeBaseRedshiftProvisionedAuthType("IAM"); + public static KnowledgeBaseRedshiftProvisionedAuthType UsernamePassword { get; } = new KnowledgeBaseRedshiftProvisionedAuthType("USERNAME_PASSWORD"); + public static KnowledgeBaseRedshiftProvisionedAuthType Username { get; } = new KnowledgeBaseRedshiftProvisionedAuthType("USERNAME"); + + public static bool operator ==(KnowledgeBaseRedshiftProvisionedAuthType left, KnowledgeBaseRedshiftProvisionedAuthType right) => left.Equals(right); + public static bool operator !=(KnowledgeBaseRedshiftProvisionedAuthType left, KnowledgeBaseRedshiftProvisionedAuthType right) => !left.Equals(right); + + public static explicit operator string(KnowledgeBaseRedshiftProvisionedAuthType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is KnowledgeBaseRedshiftProvisionedAuthType other && Equals(other); + public bool Equals(KnowledgeBaseRedshiftProvisionedAuthType other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + + /// + /// Redshift query engine storage type + /// + [EnumType] + public readonly struct KnowledgeBaseRedshiftQueryEngineStorageType : IEquatable + { + private readonly string _value; + + private KnowledgeBaseRedshiftQueryEngineStorageType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static KnowledgeBaseRedshiftQueryEngineStorageType Redshift { get; } = new KnowledgeBaseRedshiftQueryEngineStorageType("REDSHIFT"); + public static KnowledgeBaseRedshiftQueryEngineStorageType AwsDataCatalog { get; } = new KnowledgeBaseRedshiftQueryEngineStorageType("AWS_DATA_CATALOG"); + + public static bool operator ==(KnowledgeBaseRedshiftQueryEngineStorageType left, KnowledgeBaseRedshiftQueryEngineStorageType right) => left.Equals(right); + public static bool operator !=(KnowledgeBaseRedshiftQueryEngineStorageType left, KnowledgeBaseRedshiftQueryEngineStorageType right) => !left.Equals(right); + + public static explicit operator string(KnowledgeBaseRedshiftQueryEngineStorageType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is KnowledgeBaseRedshiftQueryEngineStorageType other && Equals(other); + public bool Equals(KnowledgeBaseRedshiftQueryEngineStorageType other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + + /// + /// Redshift query engine type + /// + [EnumType] + public readonly struct KnowledgeBaseRedshiftQueryEngineType : IEquatable + { + private readonly string _value; + + private KnowledgeBaseRedshiftQueryEngineType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static KnowledgeBaseRedshiftQueryEngineType Serverless { get; } = new KnowledgeBaseRedshiftQueryEngineType("SERVERLESS"); + public static KnowledgeBaseRedshiftQueryEngineType Provisioned { get; } = new KnowledgeBaseRedshiftQueryEngineType("PROVISIONED"); + + public static bool operator ==(KnowledgeBaseRedshiftQueryEngineType left, KnowledgeBaseRedshiftQueryEngineType right) => left.Equals(right); + public static bool operator !=(KnowledgeBaseRedshiftQueryEngineType left, KnowledgeBaseRedshiftQueryEngineType right) => !left.Equals(right); + + public static explicit operator string(KnowledgeBaseRedshiftQueryEngineType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is KnowledgeBaseRedshiftQueryEngineType other && Equals(other); + public bool Equals(KnowledgeBaseRedshiftQueryEngineType other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + + /// + /// Serverless Redshift auth type + /// + [EnumType] + public readonly struct KnowledgeBaseRedshiftServerlessAuthType : IEquatable + { + private readonly string _value; + + private KnowledgeBaseRedshiftServerlessAuthType(string value) + { + _value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public static KnowledgeBaseRedshiftServerlessAuthType Iam { get; } = new KnowledgeBaseRedshiftServerlessAuthType("IAM"); + public static KnowledgeBaseRedshiftServerlessAuthType UsernamePassword { get; } = new KnowledgeBaseRedshiftServerlessAuthType("USERNAME_PASSWORD"); + + public static bool operator ==(KnowledgeBaseRedshiftServerlessAuthType left, KnowledgeBaseRedshiftServerlessAuthType right) => left.Equals(right); + public static bool operator !=(KnowledgeBaseRedshiftServerlessAuthType left, KnowledgeBaseRedshiftServerlessAuthType right) => !left.Equals(right); + + public static explicit operator string(KnowledgeBaseRedshiftServerlessAuthType value) => value._value; + + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool Equals(object? obj) => obj is KnowledgeBaseRedshiftServerlessAuthType other && Equals(other); + public bool Equals(KnowledgeBaseRedshiftServerlessAuthType other) => string.Equals(_value, other._value, StringComparison.Ordinal); + + [EditorBrowsable(EditorBrowsableState.Never)] + public override int GetHashCode() => _value?.GetHashCode() ?? 0; + + public override string ToString() => _value; + } + /// /// The status of a knowledge base. /// @@ -1592,6 +1779,7 @@ private KnowledgeBaseType(string value) public static KnowledgeBaseType Vector { get; } = new KnowledgeBaseType("VECTOR"); public static KnowledgeBaseType Kendra { get; } = new KnowledgeBaseType("KENDRA"); + public static KnowledgeBaseType Sql { get; } = new KnowledgeBaseType("SQL"); public static bool operator ==(KnowledgeBaseType left, KnowledgeBaseType right) => left.Equals(right); public static bool operator !=(KnowledgeBaseType left, KnowledgeBaseType right) => !left.Equals(right); diff --git a/sdk/dotnet/Bedrock/GetKnowledgeBase.cs b/sdk/dotnet/Bedrock/GetKnowledgeBase.cs index 8a4a10062d..5021a2a609 100644 --- a/sdk/dotnet/Bedrock/GetKnowledgeBase.cs +++ b/sdk/dotnet/Bedrock/GetKnowledgeBase.cs @@ -80,6 +80,10 @@ public sealed class GetKnowledgeBaseResult /// public readonly string? KnowledgeBaseArn; /// + /// Contains details about the embeddings configuration of the knowledge base. + /// + public readonly Outputs.KnowledgeBaseConfiguration? KnowledgeBaseConfiguration; + /// /// The unique identifier of the knowledge base. /// public readonly string? KnowledgeBaseId; @@ -117,6 +121,8 @@ private GetKnowledgeBaseResult( string? knowledgeBaseArn, + Outputs.KnowledgeBaseConfiguration? knowledgeBaseConfiguration, + string? knowledgeBaseId, string? name, @@ -133,6 +139,7 @@ private GetKnowledgeBaseResult( Description = description; FailureReasons = failureReasons; KnowledgeBaseArn = knowledgeBaseArn; + KnowledgeBaseConfiguration = knowledgeBaseConfiguration; KnowledgeBaseId = knowledgeBaseId; Name = name; RoleArn = roleArn; diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseConfigurationArgs.cs index 383cf9004b..b0ce0d5dc6 100644 --- a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseConfigurationArgs.cs +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseConfigurationArgs.cs @@ -21,6 +21,9 @@ public sealed class KnowledgeBaseConfigurationArgs : global::Pulumi.ResourceArgs [Input("kendraKnowledgeBaseConfiguration")] public Input? KendraKnowledgeBaseConfiguration { get; set; } + [Input("sqlKnowledgeBaseConfiguration")] + public Input? SqlKnowledgeBaseConfiguration { get; set; } + /// /// The type of data that the data source is converted into for the knowledge base. /// diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseCuratedQueryArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseCuratedQueryArgs.cs new file mode 100644 index 0000000000..279d760a47 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseCuratedQueryArgs.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Curated query or question and answer pair + /// + public sealed class KnowledgeBaseCuratedQueryArgs : global::Pulumi.ResourceArgs + { + [Input("naturalLanguage", required: true)] + public Input NaturalLanguage { get; set; } = null!; + + [Input("sql", required: true)] + public Input Sql { get; set; } = null!; + + public KnowledgeBaseCuratedQueryArgs() + { + } + public static new KnowledgeBaseCuratedQueryArgs Empty => new KnowledgeBaseCuratedQueryArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationColumnArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationColumnArgs.cs new file mode 100644 index 0000000000..2a3aa46291 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationColumnArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Redshift query generation column + /// + public sealed class KnowledgeBaseQueryGenerationColumnArgs : global::Pulumi.ResourceArgs + { + [Input("description")] + public Input? Description { get; set; } + + [Input("inclusion")] + public Input? Inclusion { get; set; } + + [Input("name")] + public Input? Name { get; set; } + + public KnowledgeBaseQueryGenerationColumnArgs() + { + } + public static new KnowledgeBaseQueryGenerationColumnArgs Empty => new KnowledgeBaseQueryGenerationColumnArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationConfigurationArgs.cs new file mode 100644 index 0000000000..125b82837e --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationConfigurationArgs.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for generating Redshift engine queries + /// + public sealed class KnowledgeBaseQueryGenerationConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("executionTimeoutSeconds")] + public Input? ExecutionTimeoutSeconds { get; set; } + + [Input("generationContext")] + public Input? GenerationContext { get; set; } + + public KnowledgeBaseQueryGenerationConfigurationArgs() + { + } + public static new KnowledgeBaseQueryGenerationConfigurationArgs Empty => new KnowledgeBaseQueryGenerationConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationContextArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationContextArgs.cs new file mode 100644 index 0000000000..77aa422410 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationContextArgs.cs @@ -0,0 +1,39 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Context used to improve query generation + /// + public sealed class KnowledgeBaseQueryGenerationContextArgs : global::Pulumi.ResourceArgs + { + [Input("curatedQueries")] + private InputList? _curatedQueries; + public InputList CuratedQueries + { + get => _curatedQueries ?? (_curatedQueries = new InputList()); + set => _curatedQueries = value; + } + + [Input("tables")] + private InputList? _tables; + public InputList Tables + { + get => _tables ?? (_tables = new InputList()); + set => _tables = value; + } + + public KnowledgeBaseQueryGenerationContextArgs() + { + } + public static new KnowledgeBaseQueryGenerationContextArgs Empty => new KnowledgeBaseQueryGenerationContextArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationTableArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationTableArgs.cs new file mode 100644 index 0000000000..48ac99ab17 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseQueryGenerationTableArgs.cs @@ -0,0 +1,40 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Tables used for Redshift query generation context + /// + public sealed class KnowledgeBaseQueryGenerationTableArgs : global::Pulumi.ResourceArgs + { + [Input("columns")] + private InputList? _columns; + public InputList Columns + { + get => _columns ?? (_columns = new InputList()); + set => _columns = value; + } + + [Input("description")] + public Input? Description { get; set; } + + [Input("inclusion")] + public Input? Inclusion { get; set; } + + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + public KnowledgeBaseQueryGenerationTableArgs() + { + } + public static new KnowledgeBaseQueryGenerationTableArgs Empty => new KnowledgeBaseQueryGenerationTableArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftConfigurationArgs.cs new file mode 100644 index 0000000000..dd07c05b43 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftConfigurationArgs.cs @@ -0,0 +1,37 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for a Redshift knowledge base + /// + public sealed class KnowledgeBaseRedshiftConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("queryEngineConfiguration", required: true)] + public Input QueryEngineConfiguration { get; set; } = null!; + + [Input("queryGenerationConfiguration")] + public Input? QueryGenerationConfiguration { get; set; } + + [Input("storageConfigurations", required: true)] + private InputList? _storageConfigurations; + public InputList StorageConfigurations + { + get => _storageConfigurations ?? (_storageConfigurations = new InputList()); + set => _storageConfigurations = value; + } + + public KnowledgeBaseRedshiftConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftConfigurationArgs Empty => new KnowledgeBaseRedshiftConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs.cs new file mode 100644 index 0000000000..3b31b87747 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for Redshift query engine provisioned auth setup + /// + public sealed class KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs : global::Pulumi.ResourceArgs + { + /// + /// Redshift database user + /// + [Input("databaseUser")] + public Input? DatabaseUser { get; set; } + + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + [Input("usernamePasswordSecretArn")] + public Input? UsernamePasswordSecretArn { get; set; } + + public KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs Empty => new KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftProvisionedConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftProvisionedConfigurationArgs.cs new file mode 100644 index 0000000000..2502b5221a --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftProvisionedConfigurationArgs.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for provisioned Redshift query engine + /// + public sealed class KnowledgeBaseRedshiftProvisionedConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("authConfiguration", required: true)] + public Input AuthConfiguration { get; set; } = null!; + + [Input("clusterIdentifier", required: true)] + public Input ClusterIdentifier { get; set; } = null!; + + public KnowledgeBaseRedshiftProvisionedConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftProvisionedConfigurationArgs Empty => new KnowledgeBaseRedshiftProvisionedConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs.cs new file mode 100644 index 0000000000..5b2a887768 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs.cs @@ -0,0 +1,31 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for Redshift query engine AWS Data Catalog backed storage + /// + public sealed class KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("tableNames", required: true)] + private InputList? _tableNames; + public InputList TableNames + { + get => _tableNames ?? (_tableNames = new InputList()); + set => _tableNames = value; + } + + public KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs Empty => new KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineConfigurationArgs.cs new file mode 100644 index 0000000000..2b78bf13c3 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineConfigurationArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for Redshift query engine + /// + public sealed class KnowledgeBaseRedshiftQueryEngineConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("provisionedConfiguration")] + public Input? ProvisionedConfiguration { get; set; } + + [Input("serverlessConfiguration")] + public Input? ServerlessConfiguration { get; set; } + + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public KnowledgeBaseRedshiftQueryEngineConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftQueryEngineConfigurationArgs Empty => new KnowledgeBaseRedshiftQueryEngineConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs.cs new file mode 100644 index 0000000000..641d3824d2 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for Redshift query engine Redshift backed storage + /// + public sealed class KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("databaseName", required: true)] + public Input DatabaseName { get; set; } = null!; + + public KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs Empty => new KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs.cs new file mode 100644 index 0000000000..54465ffd89 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for available Redshift query engine storage types + /// + public sealed class KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("awsDataCatalogConfiguration")] + public Input? AwsDataCatalogConfiguration { get; set; } + + [Input("redshiftConfiguration")] + public Input? RedshiftConfiguration { get; set; } + + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs Empty => new KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftServerlessAuthConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftServerlessAuthConfigurationArgs.cs new file mode 100644 index 0000000000..5a90072175 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftServerlessAuthConfigurationArgs.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for Redshift query engine serverless auth setup + /// + public sealed class KnowledgeBaseRedshiftServerlessAuthConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + [Input("usernamePasswordSecretArn")] + public Input? UsernamePasswordSecretArn { get; set; } + + public KnowledgeBaseRedshiftServerlessAuthConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftServerlessAuthConfigurationArgs Empty => new KnowledgeBaseRedshiftServerlessAuthConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftServerlessConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftServerlessConfigurationArgs.cs new file mode 100644 index 0000000000..2da03de89c --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseRedshiftServerlessConfigurationArgs.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for serverless Redshift query engine + /// + public sealed class KnowledgeBaseRedshiftServerlessConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("authConfiguration", required: true)] + public Input AuthConfiguration { get; set; } = null!; + + [Input("workgroupArn", required: true)] + public Input WorkgroupArn { get; set; } = null!; + + public KnowledgeBaseRedshiftServerlessConfigurationArgs() + { + } + public static new KnowledgeBaseRedshiftServerlessConfigurationArgs Empty => new KnowledgeBaseRedshiftServerlessConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseSqlKnowledgeBaseConfigurationArgs.cs b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseSqlKnowledgeBaseConfigurationArgs.cs new file mode 100644 index 0000000000..4b567a6147 --- /dev/null +++ b/sdk/dotnet/Bedrock/Inputs/KnowledgeBaseSqlKnowledgeBaseConfigurationArgs.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Inputs +{ + + /// + /// Configurations for a SQL knowledge base + /// + public sealed class KnowledgeBaseSqlKnowledgeBaseConfigurationArgs : global::Pulumi.ResourceArgs + { + [Input("redshiftConfiguration")] + public Input? RedshiftConfiguration { get; set; } + + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public KnowledgeBaseSqlKnowledgeBaseConfigurationArgs() + { + } + public static new KnowledgeBaseSqlKnowledgeBaseConfigurationArgs Empty => new KnowledgeBaseSqlKnowledgeBaseConfigurationArgs(); + } +} diff --git a/sdk/dotnet/Bedrock/KnowledgeBase.cs b/sdk/dotnet/Bedrock/KnowledgeBase.cs index 3bb6617230..b090285fbc 100644 --- a/sdk/dotnet/Bedrock/KnowledgeBase.cs +++ b/sdk/dotnet/Bedrock/KnowledgeBase.cs @@ -115,7 +115,12 @@ private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? Version = Utilities.Version, ReplaceOnChanges = { - "knowledgeBaseConfiguration", + "knowledgeBaseConfiguration.kendraKnowledgeBaseConfiguration", + "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.redshiftConfiguration.queryEngineConfiguration", + "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.redshiftConfiguration.storageConfigurations[*]", + "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.type", + "knowledgeBaseConfiguration.type", + "knowledgeBaseConfiguration.vectorKnowledgeBaseConfiguration", "storageConfiguration", }, }; diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseConfiguration.cs index 5c6ce27b33..076cbfb21a 100644 --- a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseConfiguration.cs +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseConfiguration.cs @@ -20,6 +20,7 @@ public sealed class KnowledgeBaseConfiguration /// Settings for an Amazon Kendra knowledge base. /// public readonly Outputs.KnowledgeBaseKendraKnowledgeBaseConfiguration? KendraKnowledgeBaseConfiguration; + public readonly Outputs.KnowledgeBaseSqlKnowledgeBaseConfiguration? SqlKnowledgeBaseConfiguration; /// /// The type of data that the data source is converted into for the knowledge base. /// @@ -33,11 +34,14 @@ public sealed class KnowledgeBaseConfiguration private KnowledgeBaseConfiguration( Outputs.KnowledgeBaseKendraKnowledgeBaseConfiguration? kendraKnowledgeBaseConfiguration, + Outputs.KnowledgeBaseSqlKnowledgeBaseConfiguration? sqlKnowledgeBaseConfiguration, + Pulumi.AwsNative.Bedrock.KnowledgeBaseType type, Outputs.KnowledgeBaseVectorKnowledgeBaseConfiguration? vectorKnowledgeBaseConfiguration) { KendraKnowledgeBaseConfiguration = kendraKnowledgeBaseConfiguration; + SqlKnowledgeBaseConfiguration = sqlKnowledgeBaseConfiguration; Type = type; VectorKnowledgeBaseConfiguration = vectorKnowledgeBaseConfiguration; } diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseCuratedQuery.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseCuratedQuery.cs new file mode 100644 index 0000000000..a1c492e1ba --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseCuratedQuery.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Curated query or question and answer pair + /// + [OutputType] + public sealed class KnowledgeBaseCuratedQuery + { + public readonly string NaturalLanguage; + public readonly string Sql; + + [OutputConstructor] + private KnowledgeBaseCuratedQuery( + string naturalLanguage, + + string sql) + { + NaturalLanguage = naturalLanguage; + Sql = sql; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationColumn.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationColumn.cs new file mode 100644 index 0000000000..058de24842 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationColumn.cs @@ -0,0 +1,36 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Redshift query generation column + /// + [OutputType] + public sealed class KnowledgeBaseQueryGenerationColumn + { + public readonly string? Description; + public readonly Pulumi.AwsNative.Bedrock.KnowledgeBaseInclusionType? Inclusion; + public readonly string? Name; + + [OutputConstructor] + private KnowledgeBaseQueryGenerationColumn( + string? description, + + Pulumi.AwsNative.Bedrock.KnowledgeBaseInclusionType? inclusion, + + string? name) + { + Description = description; + Inclusion = inclusion; + Name = name; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationConfiguration.cs new file mode 100644 index 0000000000..bc100757f1 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationConfiguration.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for generating Redshift engine queries + /// + [OutputType] + public sealed class KnowledgeBaseQueryGenerationConfiguration + { + public readonly int? ExecutionTimeoutSeconds; + public readonly Outputs.KnowledgeBaseQueryGenerationContext? GenerationContext; + + [OutputConstructor] + private KnowledgeBaseQueryGenerationConfiguration( + int? executionTimeoutSeconds, + + Outputs.KnowledgeBaseQueryGenerationContext? generationContext) + { + ExecutionTimeoutSeconds = executionTimeoutSeconds; + GenerationContext = generationContext; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationContext.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationContext.cs new file mode 100644 index 0000000000..2a719bc57e --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationContext.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Context used to improve query generation + /// + [OutputType] + public sealed class KnowledgeBaseQueryGenerationContext + { + public readonly ImmutableArray CuratedQueries; + public readonly ImmutableArray Tables; + + [OutputConstructor] + private KnowledgeBaseQueryGenerationContext( + ImmutableArray curatedQueries, + + ImmutableArray tables) + { + CuratedQueries = curatedQueries; + Tables = tables; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationTable.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationTable.cs new file mode 100644 index 0000000000..b2bd2618c4 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseQueryGenerationTable.cs @@ -0,0 +1,40 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Tables used for Redshift query generation context + /// + [OutputType] + public sealed class KnowledgeBaseQueryGenerationTable + { + public readonly ImmutableArray Columns; + public readonly string? Description; + public readonly Pulumi.AwsNative.Bedrock.KnowledgeBaseInclusionType? Inclusion; + public readonly string Name; + + [OutputConstructor] + private KnowledgeBaseQueryGenerationTable( + ImmutableArray columns, + + string? description, + + Pulumi.AwsNative.Bedrock.KnowledgeBaseInclusionType? inclusion, + + string name) + { + Columns = columns; + Description = description; + Inclusion = inclusion; + Name = name; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftConfiguration.cs new file mode 100644 index 0000000000..c4088b01c5 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftConfiguration.cs @@ -0,0 +1,36 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for a Redshift knowledge base + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftConfiguration + { + public readonly Outputs.KnowledgeBaseRedshiftQueryEngineConfiguration QueryEngineConfiguration; + public readonly Outputs.KnowledgeBaseQueryGenerationConfiguration? QueryGenerationConfiguration; + public readonly ImmutableArray StorageConfigurations; + + [OutputConstructor] + private KnowledgeBaseRedshiftConfiguration( + Outputs.KnowledgeBaseRedshiftQueryEngineConfiguration queryEngineConfiguration, + + Outputs.KnowledgeBaseQueryGenerationConfiguration? queryGenerationConfiguration, + + ImmutableArray storageConfigurations) + { + QueryEngineConfiguration = queryEngineConfiguration; + QueryGenerationConfiguration = queryGenerationConfiguration; + StorageConfigurations = storageConfigurations; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftProvisionedAuthConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftProvisionedAuthConfiguration.cs new file mode 100644 index 0000000000..5b54a714e6 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftProvisionedAuthConfiguration.cs @@ -0,0 +1,39 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for Redshift query engine provisioned auth setup + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftProvisionedAuthConfiguration + { + /// + /// Redshift database user + /// + public readonly string? DatabaseUser; + public readonly Pulumi.AwsNative.Bedrock.KnowledgeBaseRedshiftProvisionedAuthType Type; + public readonly string? UsernamePasswordSecretArn; + + [OutputConstructor] + private KnowledgeBaseRedshiftProvisionedAuthConfiguration( + string? databaseUser, + + Pulumi.AwsNative.Bedrock.KnowledgeBaseRedshiftProvisionedAuthType type, + + string? usernamePasswordSecretArn) + { + DatabaseUser = databaseUser; + Type = type; + UsernamePasswordSecretArn = usernamePasswordSecretArn; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftProvisionedConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftProvisionedConfiguration.cs new file mode 100644 index 0000000000..df4673461f --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftProvisionedConfiguration.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for provisioned Redshift query engine + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftProvisionedConfiguration + { + public readonly Outputs.KnowledgeBaseRedshiftProvisionedAuthConfiguration AuthConfiguration; + public readonly string ClusterIdentifier; + + [OutputConstructor] + private KnowledgeBaseRedshiftProvisionedConfiguration( + Outputs.KnowledgeBaseRedshiftProvisionedAuthConfiguration authConfiguration, + + string clusterIdentifier) + { + AuthConfiguration = authConfiguration; + ClusterIdentifier = clusterIdentifier; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration.cs new file mode 100644 index 0000000000..fff5ccbc1c --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for Redshift query engine AWS Data Catalog backed storage + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration + { + public readonly ImmutableArray TableNames; + + [OutputConstructor] + private KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration(ImmutableArray tableNames) + { + TableNames = tableNames; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineConfiguration.cs new file mode 100644 index 0000000000..38e68563a5 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineConfiguration.cs @@ -0,0 +1,36 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for Redshift query engine + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftQueryEngineConfiguration + { + public readonly Outputs.KnowledgeBaseRedshiftProvisionedConfiguration? ProvisionedConfiguration; + public readonly Outputs.KnowledgeBaseRedshiftServerlessConfiguration? ServerlessConfiguration; + public readonly Pulumi.AwsNative.Bedrock.KnowledgeBaseRedshiftQueryEngineType Type; + + [OutputConstructor] + private KnowledgeBaseRedshiftQueryEngineConfiguration( + Outputs.KnowledgeBaseRedshiftProvisionedConfiguration? provisionedConfiguration, + + Outputs.KnowledgeBaseRedshiftServerlessConfiguration? serverlessConfiguration, + + Pulumi.AwsNative.Bedrock.KnowledgeBaseRedshiftQueryEngineType type) + { + ProvisionedConfiguration = provisionedConfiguration; + ServerlessConfiguration = serverlessConfiguration; + Type = type; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration.cs new file mode 100644 index 0000000000..63a8242643 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for Redshift query engine Redshift backed storage + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration + { + public readonly string DatabaseName; + + [OutputConstructor] + private KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration(string databaseName) + { + DatabaseName = databaseName; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineStorageConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineStorageConfiguration.cs new file mode 100644 index 0000000000..0dc66ab333 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftQueryEngineStorageConfiguration.cs @@ -0,0 +1,36 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for available Redshift query engine storage types + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftQueryEngineStorageConfiguration + { + public readonly Outputs.KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration? AwsDataCatalogConfiguration; + public readonly Outputs.KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration? RedshiftConfiguration; + public readonly Pulumi.AwsNative.Bedrock.KnowledgeBaseRedshiftQueryEngineStorageType Type; + + [OutputConstructor] + private KnowledgeBaseRedshiftQueryEngineStorageConfiguration( + Outputs.KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration? awsDataCatalogConfiguration, + + Outputs.KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration? redshiftConfiguration, + + Pulumi.AwsNative.Bedrock.KnowledgeBaseRedshiftQueryEngineStorageType type) + { + AwsDataCatalogConfiguration = awsDataCatalogConfiguration; + RedshiftConfiguration = redshiftConfiguration; + Type = type; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftServerlessAuthConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftServerlessAuthConfiguration.cs new file mode 100644 index 0000000000..433a7a35d7 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftServerlessAuthConfiguration.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for Redshift query engine serverless auth setup + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftServerlessAuthConfiguration + { + public readonly Pulumi.AwsNative.Bedrock.KnowledgeBaseRedshiftServerlessAuthType Type; + public readonly string? UsernamePasswordSecretArn; + + [OutputConstructor] + private KnowledgeBaseRedshiftServerlessAuthConfiguration( + Pulumi.AwsNative.Bedrock.KnowledgeBaseRedshiftServerlessAuthType type, + + string? usernamePasswordSecretArn) + { + Type = type; + UsernamePasswordSecretArn = usernamePasswordSecretArn; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftServerlessConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftServerlessConfiguration.cs new file mode 100644 index 0000000000..4a897b3fd7 --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseRedshiftServerlessConfiguration.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for serverless Redshift query engine + /// + [OutputType] + public sealed class KnowledgeBaseRedshiftServerlessConfiguration + { + public readonly Outputs.KnowledgeBaseRedshiftServerlessAuthConfiguration AuthConfiguration; + public readonly string WorkgroupArn; + + [OutputConstructor] + private KnowledgeBaseRedshiftServerlessConfiguration( + Outputs.KnowledgeBaseRedshiftServerlessAuthConfiguration authConfiguration, + + string workgroupArn) + { + AuthConfiguration = authConfiguration; + WorkgroupArn = workgroupArn; + } + } +} diff --git a/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseSqlKnowledgeBaseConfiguration.cs b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseSqlKnowledgeBaseConfiguration.cs new file mode 100644 index 0000000000..264ed45c7a --- /dev/null +++ b/sdk/dotnet/Bedrock/Outputs/KnowledgeBaseSqlKnowledgeBaseConfiguration.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.AwsNative.Bedrock.Outputs +{ + + /// + /// Configurations for a SQL knowledge base + /// + [OutputType] + public sealed class KnowledgeBaseSqlKnowledgeBaseConfiguration + { + public readonly Outputs.KnowledgeBaseRedshiftConfiguration? RedshiftConfiguration; + public readonly Pulumi.AwsNative.Bedrock.KnowledgeBaseQueryEngineType Type; + + [OutputConstructor] + private KnowledgeBaseSqlKnowledgeBaseConfiguration( + Outputs.KnowledgeBaseRedshiftConfiguration? redshiftConfiguration, + + Pulumi.AwsNative.Bedrock.KnowledgeBaseQueryEngineType type) + { + RedshiftConfiguration = redshiftConfiguration; + Type = type; + } + } +} diff --git a/sdk/dotnet/DataZone/DataSource.cs b/sdk/dotnet/DataZone/DataSource.cs index 0d11f75801..e917d3257f 100644 --- a/sdk/dotnet/DataZone/DataSource.cs +++ b/sdk/dotnet/DataZone/DataSource.cs @@ -33,6 +33,18 @@ public partial class DataSource : global::Pulumi.CustomResource [Output("configuration")] public Output Configuration { get; private set; } = null!; + /// + /// The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + /// + [Output("connectionId")] + public Output ConnectionId { get; private set; } = null!; + + /// + /// The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + /// + [Output("connectionIdentifier")] + public Output ConnectionIdentifier { get; private set; } = null!; + /// /// The timestamp of when the data source was created. /// @@ -73,7 +85,7 @@ public partial class DataSource : global::Pulumi.CustomResource /// The unique identifier of the Amazon DataZone environment to which the data source publishes assets. /// [Output("environmentIdentifier")] - public Output EnvironmentIdentifier { get; private set; } = null!; + public Output EnvironmentIdentifier { get; private set; } = null!; /// /// The number of assets created by the data source during its last run. @@ -172,6 +184,7 @@ private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? Version = Utilities.Version, ReplaceOnChanges = { + "connectionIdentifier", "domainIdentifier", "environmentIdentifier", "projectIdentifier", @@ -217,6 +230,12 @@ public InputList AssetFormsInput [Input("configuration")] public object? Configuration { get; set; } + /// + /// The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + /// + [Input("connectionIdentifier")] + public Input? ConnectionIdentifier { get; set; } + /// /// The description of the data source. /// @@ -238,8 +257,8 @@ public InputList AssetFormsInput /// /// The unique identifier of the Amazon DataZone environment to which the data source publishes assets. /// - [Input("environmentIdentifier", required: true)] - public Input EnvironmentIdentifier { get; set; } = null!; + [Input("environmentIdentifier")] + public Input? EnvironmentIdentifier { get; set; } /// /// The name of the data source. diff --git a/sdk/dotnet/DataZone/GetDataSource.cs b/sdk/dotnet/DataZone/GetDataSource.cs index 0180bd60c3..a41a6e66e6 100644 --- a/sdk/dotnet/DataZone/GetDataSource.cs +++ b/sdk/dotnet/DataZone/GetDataSource.cs @@ -75,6 +75,10 @@ public GetDataSourceInvokeArgs() [OutputType] public sealed class GetDataSourceResult { + /// + /// The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + /// + public readonly string? ConnectionId; /// /// The timestamp of when the data source was created. /// @@ -142,6 +146,8 @@ public sealed class GetDataSourceResult [OutputConstructor] private GetDataSourceResult( + string? connectionId, + string? createdAt, string? description, @@ -174,6 +180,7 @@ private GetDataSourceResult( string? updatedAt) { + ConnectionId = connectionId; CreatedAt = createdAt; Description = description; DomainId = domainId; diff --git a/sdk/dotnet/DataZone/Inputs/DataSourceGlueRunConfigurationInputArgs.cs b/sdk/dotnet/DataZone/Inputs/DataSourceGlueRunConfigurationInputArgs.cs index 01f488f818..942fbaad55 100644 --- a/sdk/dotnet/DataZone/Inputs/DataSourceGlueRunConfigurationInputArgs.cs +++ b/sdk/dotnet/DataZone/Inputs/DataSourceGlueRunConfigurationInputArgs.cs @@ -18,6 +18,12 @@ public sealed class DataSourceGlueRunConfigurationInputArgs : global::Pulumi.Res [Input("autoImportDataQualityResult")] public Input? AutoImportDataQualityResult { get; set; } + /// + /// The catalog name in the AWS Glue run configuration. + /// + [Input("catalogName")] + public Input? CatalogName { get; set; } + /// /// The data access role included in the configuration details of the AWS Glue data source. /// diff --git a/sdk/dotnet/DataZone/Inputs/DataSourceRedshiftRunConfigurationInputArgs.cs b/sdk/dotnet/DataZone/Inputs/DataSourceRedshiftRunConfigurationInputArgs.cs index 090e1ca6fc..c0071fd21d 100644 --- a/sdk/dotnet/DataZone/Inputs/DataSourceRedshiftRunConfigurationInputArgs.cs +++ b/sdk/dotnet/DataZone/Inputs/DataSourceRedshiftRunConfigurationInputArgs.cs @@ -24,14 +24,14 @@ public sealed class DataSourceRedshiftRunConfigurationInputArgs : global::Pulumi /// /// The details of the credentials required to access an Amazon Redshift cluster. /// - [Input("redshiftCredentialConfiguration", required: true)] - public Input RedshiftCredentialConfiguration { get; set; } = null!; + [Input("redshiftCredentialConfiguration")] + public Input? RedshiftCredentialConfiguration { get; set; } /// /// The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. /// - [Input("redshiftStorage", required: true)] - public InputUnion RedshiftStorage { get; set; } = null!; + [Input("redshiftStorage")] + public InputUnion? RedshiftStorage { get; set; } [Input("relationalFilterConfigurations", required: true)] private InputList? _relationalFilterConfigurations; diff --git a/sdk/dotnet/DataZone/Outputs/DataSourceGlueRunConfigurationInput.cs b/sdk/dotnet/DataZone/Outputs/DataSourceGlueRunConfigurationInput.cs index 1c0f420f8d..05f1f23c8d 100644 --- a/sdk/dotnet/DataZone/Outputs/DataSourceGlueRunConfigurationInput.cs +++ b/sdk/dotnet/DataZone/Outputs/DataSourceGlueRunConfigurationInput.cs @@ -18,6 +18,10 @@ public sealed class DataSourceGlueRunConfigurationInput /// public readonly bool? AutoImportDataQualityResult; /// + /// The catalog name in the AWS Glue run configuration. + /// + public readonly string? CatalogName; + /// /// The data access role included in the configuration details of the AWS Glue data source. /// public readonly string? DataAccessRole; @@ -30,11 +34,14 @@ public sealed class DataSourceGlueRunConfigurationInput private DataSourceGlueRunConfigurationInput( bool? autoImportDataQualityResult, + string? catalogName, + string? dataAccessRole, ImmutableArray relationalFilterConfigurations) { AutoImportDataQualityResult = autoImportDataQualityResult; + CatalogName = catalogName; DataAccessRole = dataAccessRole; RelationalFilterConfigurations = relationalFilterConfigurations; } diff --git a/sdk/dotnet/DataZone/Outputs/DataSourceRedshiftRunConfigurationInput.cs b/sdk/dotnet/DataZone/Outputs/DataSourceRedshiftRunConfigurationInput.cs index d8ee5bae68..4e9a619494 100644 --- a/sdk/dotnet/DataZone/Outputs/DataSourceRedshiftRunConfigurationInput.cs +++ b/sdk/dotnet/DataZone/Outputs/DataSourceRedshiftRunConfigurationInput.cs @@ -23,20 +23,20 @@ public sealed class DataSourceRedshiftRunConfigurationInput /// /// The details of the credentials required to access an Amazon Redshift cluster. /// - public readonly Outputs.DataSourceRedshiftCredentialConfiguration RedshiftCredentialConfiguration; + public readonly Outputs.DataSourceRedshiftCredentialConfiguration? RedshiftCredentialConfiguration; /// /// The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. /// - public readonly Union RedshiftStorage; + public readonly Union? RedshiftStorage; public readonly ImmutableArray RelationalFilterConfigurations; [OutputConstructor] private DataSourceRedshiftRunConfigurationInput( string? dataAccessRole, - Outputs.DataSourceRedshiftCredentialConfiguration redshiftCredentialConfiguration, + Outputs.DataSourceRedshiftCredentialConfiguration? redshiftCredentialConfiguration, - Union redshiftStorage, + Union? redshiftStorage, ImmutableArray relationalFilterConfigurations) { diff --git a/sdk/dotnet/Enums.cs b/sdk/dotnet/Enums.cs index 3009eae406..c5048d8525 100644 --- a/sdk/dotnet/Enums.cs +++ b/sdk/dotnet/Enums.cs @@ -137,6 +137,10 @@ private Region(string value) /// public static Region MeSouth1 { get; } = new Region("me-south-1"); /// + /// Mexico (Central) + /// + public static Region MxCentral1 { get; } = new Region("mx-central-1"); + /// /// South America (Sao Paulo) /// public static Region SaEast1 { get; } = new Region("sa-east-1"); diff --git a/sdk/dotnet/Rds/DbInstance.cs b/sdk/dotnet/Rds/DbInstance.cs index 5cfff9d364..2fc4811ec4 100644 --- a/sdk/dotnet/Rds/DbInstance.cs +++ b/sdk/dotnet/Rds/DbInstance.cs @@ -199,11 +199,7 @@ public partial class DbInstance : global::Pulumi.CustomResource public Output CustomIamInstanceProfile { get; private set; } = null!; /// - /// The mode of Database Insights to enable for the DB instance. - /// - /// This setting only applies to Amazon Aurora DB instances. - /// - /// > Currently, this value is inherited from the DB cluster and can't be changed. + /// The mode of Database Insights that is enabled for the instance. /// [Output("databaseInsightsMode")] public Output DatabaseInsightsMode { get; private set; } = null!; diff --git a/sdk/dotnet/Rds/GetDbInstance.cs b/sdk/dotnet/Rds/GetDbInstance.cs index 8defef9044..19b694092a 100644 --- a/sdk/dotnet/Rds/GetDbInstance.cs +++ b/sdk/dotnet/Rds/GetDbInstance.cs @@ -226,11 +226,7 @@ public sealed class GetDbInstanceResult /// public readonly bool? CopyTagsToSnapshot; /// - /// The mode of Database Insights to enable for the DB instance. - /// - /// This setting only applies to Amazon Aurora DB instances. - /// - /// > Currently, this value is inherited from the DB cluster and can't be changed. + /// The mode of Database Insights that is enabled for the instance. /// public readonly string? DatabaseInsightsMode; /// diff --git a/sdk/dotnet/Sns/GetTopic.cs b/sdk/dotnet/Sns/GetTopic.cs index fefce24bec..6901c47b75 100644 --- a/sdk/dotnet/Sns/GetTopic.cs +++ b/sdk/dotnet/Sns/GetTopic.cs @@ -106,6 +106,7 @@ public sealed class GetTopicResult /// The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs. /// public readonly string? DisplayName; + public readonly string? FifoThroughputScope; /// /// The ID of an AWS managed customer master key (CMK) for SNS or a custom CMK. For more information, see [Key terms](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms). For more examples, see ``KeyId`` in the *API Reference*. /// This property applies only to [server-side-encryption](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html). @@ -146,6 +147,8 @@ private GetTopicResult( string? displayName, + string? fifoThroughputScope, + string? kmsMasterKeyId, string? signatureVersion, @@ -163,6 +166,7 @@ private GetTopicResult( DataProtectionPolicy = dataProtectionPolicy; DeliveryStatusLogging = deliveryStatusLogging; DisplayName = displayName; + FifoThroughputScope = fifoThroughputScope; KmsMasterKeyId = kmsMasterKeyId; SignatureVersion = signatureVersion; Subscription = subscription; diff --git a/sdk/dotnet/Sns/Topic.cs b/sdk/dotnet/Sns/Topic.cs index ae5de1f788..b9d4a92271 100644 --- a/sdk/dotnet/Sns/Topic.cs +++ b/sdk/dotnet/Sns/Topic.cs @@ -194,6 +194,9 @@ public partial class Topic : global::Pulumi.CustomResource [Output("displayName")] public Output DisplayName { get; private set; } = null!; + [Output("fifoThroughputScope")] + public Output FifoThroughputScope { get; private set; } = null!; + /// /// Set to true to create a FIFO topic. /// @@ -350,6 +353,9 @@ public InputList DeliveryStatusLogging [Input("displayName")] public Input? DisplayName { get; set; } + [Input("fifoThroughputScope")] + public Input? FifoThroughputScope { get; set; } + /// /// Set to true to create a FIFO topic. /// diff --git a/sdk/dotnet/Ssm/Association.cs b/sdk/dotnet/Ssm/Association.cs index febd763a50..bbd376d857 100644 --- a/sdk/dotnet/Ssm/Association.cs +++ b/sdk/dotnet/Ssm/Association.cs @@ -240,7 +240,7 @@ public partial class Association : global::Pulumi.CustomResource public Output AssociationName { get; private set; } = null!; /// - /// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + /// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . /// [Output("automationTargetParameterName")] public Output AutomationTargetParameterName { get; private set; } = null!; @@ -397,7 +397,7 @@ public sealed class AssociationArgs : global::Pulumi.ResourceArgs public Input? AssociationName { get; set; } /// - /// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + /// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . /// [Input("automationTargetParameterName")] public Input? AutomationTargetParameterName { get; set; } diff --git a/sdk/dotnet/Ssm/GetAssociation.cs b/sdk/dotnet/Ssm/GetAssociation.cs index bd66051e6b..3baaaf1f14 100644 --- a/sdk/dotnet/Ssm/GetAssociation.cs +++ b/sdk/dotnet/Ssm/GetAssociation.cs @@ -76,7 +76,7 @@ public sealed class GetAssociationResult /// public readonly string? AssociationName; /// - /// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + /// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . /// public readonly string? AutomationTargetParameterName; /// diff --git a/sdk/go/aws/bedrock/getKnowledgeBase.go b/sdk/go/aws/bedrock/getKnowledgeBase.go index 509d4b8b50..5da6789f73 100644 --- a/sdk/go/aws/bedrock/getKnowledgeBase.go +++ b/sdk/go/aws/bedrock/getKnowledgeBase.go @@ -36,6 +36,8 @@ type LookupKnowledgeBaseResult struct { FailureReasons []string `pulumi:"failureReasons"` // The ARN of the knowledge base. KnowledgeBaseArn *string `pulumi:"knowledgeBaseArn"` + // Contains details about the embeddings configuration of the knowledge base. + KnowledgeBaseConfiguration *KnowledgeBaseConfiguration `pulumi:"knowledgeBaseConfiguration"` // The unique identifier of the knowledge base. KnowledgeBaseId *string `pulumi:"knowledgeBaseId"` // The name of the knowledge base. @@ -105,6 +107,11 @@ func (o LookupKnowledgeBaseResultOutput) KnowledgeBaseArn() pulumi.StringPtrOutp return o.ApplyT(func(v LookupKnowledgeBaseResult) *string { return v.KnowledgeBaseArn }).(pulumi.StringPtrOutput) } +// Contains details about the embeddings configuration of the knowledge base. +func (o LookupKnowledgeBaseResultOutput) KnowledgeBaseConfiguration() KnowledgeBaseConfigurationPtrOutput { + return o.ApplyT(func(v LookupKnowledgeBaseResult) *KnowledgeBaseConfiguration { return v.KnowledgeBaseConfiguration }).(KnowledgeBaseConfigurationPtrOutput) +} + // The unique identifier of the knowledge base. func (o LookupKnowledgeBaseResultOutput) KnowledgeBaseId() pulumi.StringPtrOutput { return o.ApplyT(func(v LookupKnowledgeBaseResult) *string { return v.KnowledgeBaseId }).(pulumi.StringPtrOutput) diff --git a/sdk/go/aws/bedrock/knowledgeBase.go b/sdk/go/aws/bedrock/knowledgeBase.go index f389ab5732..82af6e2694 100644 --- a/sdk/go/aws/bedrock/knowledgeBase.go +++ b/sdk/go/aws/bedrock/knowledgeBase.go @@ -59,7 +59,12 @@ func NewKnowledgeBase(ctx *pulumi.Context, return nil, errors.New("invalid value for required argument 'RoleArn'") } replaceOnChanges := pulumi.ReplaceOnChanges([]string{ - "knowledgeBaseConfiguration", + "knowledgeBaseConfiguration.kendraKnowledgeBaseConfiguration", + "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.redshiftConfiguration.queryEngineConfiguration", + "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.redshiftConfiguration.storageConfigurations[*]", + "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.type", + "knowledgeBaseConfiguration.type", + "knowledgeBaseConfiguration.vectorKnowledgeBaseConfiguration", "storageConfiguration", }) opts = append(opts, replaceOnChanges) diff --git a/sdk/go/aws/bedrock/pulumiEnums.go b/sdk/go/aws/bedrock/pulumiEnums.go index bad87215a5..2d485eb945 100644 --- a/sdk/go/aws/bedrock/pulumiEnums.go +++ b/sdk/go/aws/bedrock/pulumiEnums.go @@ -3796,12 +3796,13 @@ func (in *dataSourceTransformationStepToApplyPtr) ToDataSourceTransformationStep type DataSourceType string const ( - DataSourceTypeS3 = DataSourceType("S3") - DataSourceTypeConfluence = DataSourceType("CONFLUENCE") - DataSourceTypeSalesforce = DataSourceType("SALESFORCE") - DataSourceTypeSharepoint = DataSourceType("SHAREPOINT") - DataSourceTypeWeb = DataSourceType("WEB") - DataSourceTypeCustom = DataSourceType("CUSTOM") + DataSourceTypeS3 = DataSourceType("S3") + DataSourceTypeConfluence = DataSourceType("CONFLUENCE") + DataSourceTypeSalesforce = DataSourceType("SALESFORCE") + DataSourceTypeSharepoint = DataSourceType("SHAREPOINT") + DataSourceTypeWeb = DataSourceType("WEB") + DataSourceTypeCustom = DataSourceType("CUSTOM") + DataSourceTypeRedshiftMetadata = DataSourceType("REDSHIFT_METADATA") ) func (DataSourceType) ElementType() reflect.Type { @@ -3932,6 +3933,7 @@ func (o DataSourceTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Contex // DataSourceTypeSharepoint // DataSourceTypeWeb // DataSourceTypeCustom +// DataSourceTypeRedshiftMetadata type DataSourceTypeInput interface { pulumi.Input @@ -6705,6 +6707,1002 @@ func (in *guardrailTopicTypePtr) ToGuardrailTopicTypePtrOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, in).(GuardrailTopicTypePtrOutput) } +// Include or Exclude status for an entity +type KnowledgeBaseInclusionType string + +const ( + KnowledgeBaseInclusionTypeInclude = KnowledgeBaseInclusionType("INCLUDE") + KnowledgeBaseInclusionTypeExclude = KnowledgeBaseInclusionType("EXCLUDE") +) + +func (KnowledgeBaseInclusionType) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseInclusionType)(nil)).Elem() +} + +func (e KnowledgeBaseInclusionType) ToKnowledgeBaseInclusionTypeOutput() KnowledgeBaseInclusionTypeOutput { + return pulumi.ToOutput(e).(KnowledgeBaseInclusionTypeOutput) +} + +func (e KnowledgeBaseInclusionType) ToKnowledgeBaseInclusionTypeOutputWithContext(ctx context.Context) KnowledgeBaseInclusionTypeOutput { + return pulumi.ToOutputWithContext(ctx, e).(KnowledgeBaseInclusionTypeOutput) +} + +func (e KnowledgeBaseInclusionType) ToKnowledgeBaseInclusionTypePtrOutput() KnowledgeBaseInclusionTypePtrOutput { + return e.ToKnowledgeBaseInclusionTypePtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseInclusionType) ToKnowledgeBaseInclusionTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseInclusionTypePtrOutput { + return KnowledgeBaseInclusionType(e).ToKnowledgeBaseInclusionTypeOutputWithContext(ctx).ToKnowledgeBaseInclusionTypePtrOutputWithContext(ctx) +} + +func (e KnowledgeBaseInclusionType) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseInclusionType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseInclusionType) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseInclusionType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type KnowledgeBaseInclusionTypeOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseInclusionTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseInclusionType)(nil)).Elem() +} + +func (o KnowledgeBaseInclusionTypeOutput) ToKnowledgeBaseInclusionTypeOutput() KnowledgeBaseInclusionTypeOutput { + return o +} + +func (o KnowledgeBaseInclusionTypeOutput) ToKnowledgeBaseInclusionTypeOutputWithContext(ctx context.Context) KnowledgeBaseInclusionTypeOutput { + return o +} + +func (o KnowledgeBaseInclusionTypeOutput) ToKnowledgeBaseInclusionTypePtrOutput() KnowledgeBaseInclusionTypePtrOutput { + return o.ToKnowledgeBaseInclusionTypePtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseInclusionTypeOutput) ToKnowledgeBaseInclusionTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseInclusionTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseInclusionType) *KnowledgeBaseInclusionType { + return &v + }).(KnowledgeBaseInclusionTypePtrOutput) +} + +func (o KnowledgeBaseInclusionTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseInclusionTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseInclusionType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o KnowledgeBaseInclusionTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseInclusionTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseInclusionType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseInclusionTypePtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseInclusionTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseInclusionType)(nil)).Elem() +} + +func (o KnowledgeBaseInclusionTypePtrOutput) ToKnowledgeBaseInclusionTypePtrOutput() KnowledgeBaseInclusionTypePtrOutput { + return o +} + +func (o KnowledgeBaseInclusionTypePtrOutput) ToKnowledgeBaseInclusionTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseInclusionTypePtrOutput { + return o +} + +func (o KnowledgeBaseInclusionTypePtrOutput) Elem() KnowledgeBaseInclusionTypeOutput { + return o.ApplyT(func(v *KnowledgeBaseInclusionType) KnowledgeBaseInclusionType { + if v != nil { + return *v + } + var ret KnowledgeBaseInclusionType + return ret + }).(KnowledgeBaseInclusionTypeOutput) +} + +func (o KnowledgeBaseInclusionTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseInclusionTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *KnowledgeBaseInclusionType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// KnowledgeBaseInclusionTypeInput is an input type that accepts values of the KnowledgeBaseInclusionType enum +// A concrete instance of `KnowledgeBaseInclusionTypeInput` can be one of the following: +// +// KnowledgeBaseInclusionTypeInclude +// KnowledgeBaseInclusionTypeExclude +type KnowledgeBaseInclusionTypeInput interface { + pulumi.Input + + ToKnowledgeBaseInclusionTypeOutput() KnowledgeBaseInclusionTypeOutput + ToKnowledgeBaseInclusionTypeOutputWithContext(context.Context) KnowledgeBaseInclusionTypeOutput +} + +var knowledgeBaseInclusionTypePtrType = reflect.TypeOf((**KnowledgeBaseInclusionType)(nil)).Elem() + +type KnowledgeBaseInclusionTypePtrInput interface { + pulumi.Input + + ToKnowledgeBaseInclusionTypePtrOutput() KnowledgeBaseInclusionTypePtrOutput + ToKnowledgeBaseInclusionTypePtrOutputWithContext(context.Context) KnowledgeBaseInclusionTypePtrOutput +} + +type knowledgeBaseInclusionTypePtr string + +func KnowledgeBaseInclusionTypePtr(v string) KnowledgeBaseInclusionTypePtrInput { + return (*knowledgeBaseInclusionTypePtr)(&v) +} + +func (*knowledgeBaseInclusionTypePtr) ElementType() reflect.Type { + return knowledgeBaseInclusionTypePtrType +} + +func (in *knowledgeBaseInclusionTypePtr) ToKnowledgeBaseInclusionTypePtrOutput() KnowledgeBaseInclusionTypePtrOutput { + return pulumi.ToOutput(in).(KnowledgeBaseInclusionTypePtrOutput) +} + +func (in *knowledgeBaseInclusionTypePtr) ToKnowledgeBaseInclusionTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseInclusionTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(KnowledgeBaseInclusionTypePtrOutput) +} + +// SQL query engine type +type KnowledgeBaseQueryEngineType string + +const ( + KnowledgeBaseQueryEngineTypeRedshift = KnowledgeBaseQueryEngineType("REDSHIFT") +) + +func (KnowledgeBaseQueryEngineType) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryEngineType)(nil)).Elem() +} + +func (e KnowledgeBaseQueryEngineType) ToKnowledgeBaseQueryEngineTypeOutput() KnowledgeBaseQueryEngineTypeOutput { + return pulumi.ToOutput(e).(KnowledgeBaseQueryEngineTypeOutput) +} + +func (e KnowledgeBaseQueryEngineType) ToKnowledgeBaseQueryEngineTypeOutputWithContext(ctx context.Context) KnowledgeBaseQueryEngineTypeOutput { + return pulumi.ToOutputWithContext(ctx, e).(KnowledgeBaseQueryEngineTypeOutput) +} + +func (e KnowledgeBaseQueryEngineType) ToKnowledgeBaseQueryEngineTypePtrOutput() KnowledgeBaseQueryEngineTypePtrOutput { + return e.ToKnowledgeBaseQueryEngineTypePtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseQueryEngineType) ToKnowledgeBaseQueryEngineTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryEngineTypePtrOutput { + return KnowledgeBaseQueryEngineType(e).ToKnowledgeBaseQueryEngineTypeOutputWithContext(ctx).ToKnowledgeBaseQueryEngineTypePtrOutputWithContext(ctx) +} + +func (e KnowledgeBaseQueryEngineType) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseQueryEngineType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseQueryEngineType) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseQueryEngineType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type KnowledgeBaseQueryEngineTypeOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseQueryEngineTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryEngineType)(nil)).Elem() +} + +func (o KnowledgeBaseQueryEngineTypeOutput) ToKnowledgeBaseQueryEngineTypeOutput() KnowledgeBaseQueryEngineTypeOutput { + return o +} + +func (o KnowledgeBaseQueryEngineTypeOutput) ToKnowledgeBaseQueryEngineTypeOutputWithContext(ctx context.Context) KnowledgeBaseQueryEngineTypeOutput { + return o +} + +func (o KnowledgeBaseQueryEngineTypeOutput) ToKnowledgeBaseQueryEngineTypePtrOutput() KnowledgeBaseQueryEngineTypePtrOutput { + return o.ToKnowledgeBaseQueryEngineTypePtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseQueryEngineTypeOutput) ToKnowledgeBaseQueryEngineTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryEngineTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseQueryEngineType) *KnowledgeBaseQueryEngineType { + return &v + }).(KnowledgeBaseQueryEngineTypePtrOutput) +} + +func (o KnowledgeBaseQueryEngineTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseQueryEngineTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseQueryEngineType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o KnowledgeBaseQueryEngineTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseQueryEngineTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseQueryEngineType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseQueryEngineTypePtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseQueryEngineTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseQueryEngineType)(nil)).Elem() +} + +func (o KnowledgeBaseQueryEngineTypePtrOutput) ToKnowledgeBaseQueryEngineTypePtrOutput() KnowledgeBaseQueryEngineTypePtrOutput { + return o +} + +func (o KnowledgeBaseQueryEngineTypePtrOutput) ToKnowledgeBaseQueryEngineTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryEngineTypePtrOutput { + return o +} + +func (o KnowledgeBaseQueryEngineTypePtrOutput) Elem() KnowledgeBaseQueryEngineTypeOutput { + return o.ApplyT(func(v *KnowledgeBaseQueryEngineType) KnowledgeBaseQueryEngineType { + if v != nil { + return *v + } + var ret KnowledgeBaseQueryEngineType + return ret + }).(KnowledgeBaseQueryEngineTypeOutput) +} + +func (o KnowledgeBaseQueryEngineTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseQueryEngineTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *KnowledgeBaseQueryEngineType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// KnowledgeBaseQueryEngineTypeInput is an input type that accepts values of the KnowledgeBaseQueryEngineType enum +// A concrete instance of `KnowledgeBaseQueryEngineTypeInput` can be one of the following: +// +// KnowledgeBaseQueryEngineTypeRedshift +type KnowledgeBaseQueryEngineTypeInput interface { + pulumi.Input + + ToKnowledgeBaseQueryEngineTypeOutput() KnowledgeBaseQueryEngineTypeOutput + ToKnowledgeBaseQueryEngineTypeOutputWithContext(context.Context) KnowledgeBaseQueryEngineTypeOutput +} + +var knowledgeBaseQueryEngineTypePtrType = reflect.TypeOf((**KnowledgeBaseQueryEngineType)(nil)).Elem() + +type KnowledgeBaseQueryEngineTypePtrInput interface { + pulumi.Input + + ToKnowledgeBaseQueryEngineTypePtrOutput() KnowledgeBaseQueryEngineTypePtrOutput + ToKnowledgeBaseQueryEngineTypePtrOutputWithContext(context.Context) KnowledgeBaseQueryEngineTypePtrOutput +} + +type knowledgeBaseQueryEngineTypePtr string + +func KnowledgeBaseQueryEngineTypePtr(v string) KnowledgeBaseQueryEngineTypePtrInput { + return (*knowledgeBaseQueryEngineTypePtr)(&v) +} + +func (*knowledgeBaseQueryEngineTypePtr) ElementType() reflect.Type { + return knowledgeBaseQueryEngineTypePtrType +} + +func (in *knowledgeBaseQueryEngineTypePtr) ToKnowledgeBaseQueryEngineTypePtrOutput() KnowledgeBaseQueryEngineTypePtrOutput { + return pulumi.ToOutput(in).(KnowledgeBaseQueryEngineTypePtrOutput) +} + +func (in *knowledgeBaseQueryEngineTypePtr) ToKnowledgeBaseQueryEngineTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryEngineTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(KnowledgeBaseQueryEngineTypePtrOutput) +} + +// Provisioned Redshift auth type +type KnowledgeBaseRedshiftProvisionedAuthType string + +const ( + KnowledgeBaseRedshiftProvisionedAuthTypeIam = KnowledgeBaseRedshiftProvisionedAuthType("IAM") + KnowledgeBaseRedshiftProvisionedAuthTypeUsernamePassword = KnowledgeBaseRedshiftProvisionedAuthType("USERNAME_PASSWORD") + KnowledgeBaseRedshiftProvisionedAuthTypeUsername = KnowledgeBaseRedshiftProvisionedAuthType("USERNAME") +) + +func (KnowledgeBaseRedshiftProvisionedAuthType) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedAuthType)(nil)).Elem() +} + +func (e KnowledgeBaseRedshiftProvisionedAuthType) ToKnowledgeBaseRedshiftProvisionedAuthTypeOutput() KnowledgeBaseRedshiftProvisionedAuthTypeOutput { + return pulumi.ToOutput(e).(KnowledgeBaseRedshiftProvisionedAuthTypeOutput) +} + +func (e KnowledgeBaseRedshiftProvisionedAuthType) ToKnowledgeBaseRedshiftProvisionedAuthTypeOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthTypeOutput { + return pulumi.ToOutputWithContext(ctx, e).(KnowledgeBaseRedshiftProvisionedAuthTypeOutput) +} + +func (e KnowledgeBaseRedshiftProvisionedAuthType) ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutput() KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return e.ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseRedshiftProvisionedAuthType) ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return KnowledgeBaseRedshiftProvisionedAuthType(e).ToKnowledgeBaseRedshiftProvisionedAuthTypeOutputWithContext(ctx).ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutputWithContext(ctx) +} + +func (e KnowledgeBaseRedshiftProvisionedAuthType) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseRedshiftProvisionedAuthType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseRedshiftProvisionedAuthType) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseRedshiftProvisionedAuthType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type KnowledgeBaseRedshiftProvisionedAuthTypeOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedAuthType)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ToKnowledgeBaseRedshiftProvisionedAuthTypeOutput() KnowledgeBaseRedshiftProvisionedAuthTypeOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ToKnowledgeBaseRedshiftProvisionedAuthTypeOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthTypeOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutput() KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return o.ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftProvisionedAuthType) *KnowledgeBaseRedshiftProvisionedAuthType { + return &v + }).(KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseRedshiftProvisionedAuthType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseRedshiftProvisionedAuthType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftProvisionedAuthType)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutput() KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) Elem() KnowledgeBaseRedshiftProvisionedAuthTypeOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftProvisionedAuthType) KnowledgeBaseRedshiftProvisionedAuthType { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftProvisionedAuthType + return ret + }).(KnowledgeBaseRedshiftProvisionedAuthTypeOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *KnowledgeBaseRedshiftProvisionedAuthType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// KnowledgeBaseRedshiftProvisionedAuthTypeInput is an input type that accepts values of the KnowledgeBaseRedshiftProvisionedAuthType enum +// A concrete instance of `KnowledgeBaseRedshiftProvisionedAuthTypeInput` can be one of the following: +// +// KnowledgeBaseRedshiftProvisionedAuthTypeIam +// KnowledgeBaseRedshiftProvisionedAuthTypeUsernamePassword +// KnowledgeBaseRedshiftProvisionedAuthTypeUsername +type KnowledgeBaseRedshiftProvisionedAuthTypeInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftProvisionedAuthTypeOutput() KnowledgeBaseRedshiftProvisionedAuthTypeOutput + ToKnowledgeBaseRedshiftProvisionedAuthTypeOutputWithContext(context.Context) KnowledgeBaseRedshiftProvisionedAuthTypeOutput +} + +var knowledgeBaseRedshiftProvisionedAuthTypePtrType = reflect.TypeOf((**KnowledgeBaseRedshiftProvisionedAuthType)(nil)).Elem() + +type KnowledgeBaseRedshiftProvisionedAuthTypePtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutput() KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput + ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutputWithContext(context.Context) KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput +} + +type knowledgeBaseRedshiftProvisionedAuthTypePtr string + +func KnowledgeBaseRedshiftProvisionedAuthTypePtr(v string) KnowledgeBaseRedshiftProvisionedAuthTypePtrInput { + return (*knowledgeBaseRedshiftProvisionedAuthTypePtr)(&v) +} + +func (*knowledgeBaseRedshiftProvisionedAuthTypePtr) ElementType() reflect.Type { + return knowledgeBaseRedshiftProvisionedAuthTypePtrType +} + +func (in *knowledgeBaseRedshiftProvisionedAuthTypePtr) ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutput() KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return pulumi.ToOutput(in).(KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) +} + +func (in *knowledgeBaseRedshiftProvisionedAuthTypePtr) ToKnowledgeBaseRedshiftProvisionedAuthTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) +} + +// Redshift query engine storage type +type KnowledgeBaseRedshiftQueryEngineStorageType string + +const ( + KnowledgeBaseRedshiftQueryEngineStorageTypeRedshift = KnowledgeBaseRedshiftQueryEngineStorageType("REDSHIFT") + KnowledgeBaseRedshiftQueryEngineStorageTypeAwsDataCatalog = KnowledgeBaseRedshiftQueryEngineStorageType("AWS_DATA_CATALOG") +) + +func (KnowledgeBaseRedshiftQueryEngineStorageType) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineStorageType)(nil)).Elem() +} + +func (e KnowledgeBaseRedshiftQueryEngineStorageType) ToKnowledgeBaseRedshiftQueryEngineStorageTypeOutput() KnowledgeBaseRedshiftQueryEngineStorageTypeOutput { + return pulumi.ToOutput(e).(KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) +} + +func (e KnowledgeBaseRedshiftQueryEngineStorageType) ToKnowledgeBaseRedshiftQueryEngineStorageTypeOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageTypeOutput { + return pulumi.ToOutputWithContext(ctx, e).(KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) +} + +func (e KnowledgeBaseRedshiftQueryEngineStorageType) ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput() KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput { + return e.ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseRedshiftQueryEngineStorageType) ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput { + return KnowledgeBaseRedshiftQueryEngineStorageType(e).ToKnowledgeBaseRedshiftQueryEngineStorageTypeOutputWithContext(ctx).ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutputWithContext(ctx) +} + +func (e KnowledgeBaseRedshiftQueryEngineStorageType) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseRedshiftQueryEngineStorageType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseRedshiftQueryEngineStorageType) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseRedshiftQueryEngineStorageType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type KnowledgeBaseRedshiftQueryEngineStorageTypeOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineStorageType)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ToKnowledgeBaseRedshiftQueryEngineStorageTypeOutput() KnowledgeBaseRedshiftQueryEngineStorageTypeOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ToKnowledgeBaseRedshiftQueryEngineStorageTypeOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageTypeOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput() KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput { + return o.ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftQueryEngineStorageType) *KnowledgeBaseRedshiftQueryEngineStorageType { + return &v + }).(KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseRedshiftQueryEngineStorageType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseRedshiftQueryEngineStorageType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineStorageType)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput() KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) Elem() KnowledgeBaseRedshiftQueryEngineStorageTypeOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineStorageType) KnowledgeBaseRedshiftQueryEngineStorageType { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftQueryEngineStorageType + return ret + }).(KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *KnowledgeBaseRedshiftQueryEngineStorageType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// KnowledgeBaseRedshiftQueryEngineStorageTypeInput is an input type that accepts values of the KnowledgeBaseRedshiftQueryEngineStorageType enum +// A concrete instance of `KnowledgeBaseRedshiftQueryEngineStorageTypeInput` can be one of the following: +// +// KnowledgeBaseRedshiftQueryEngineStorageTypeRedshift +// KnowledgeBaseRedshiftQueryEngineStorageTypeAwsDataCatalog +type KnowledgeBaseRedshiftQueryEngineStorageTypeInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineStorageTypeOutput() KnowledgeBaseRedshiftQueryEngineStorageTypeOutput + ToKnowledgeBaseRedshiftQueryEngineStorageTypeOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineStorageTypeOutput +} + +var knowledgeBaseRedshiftQueryEngineStorageTypePtrType = reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineStorageType)(nil)).Elem() + +type KnowledgeBaseRedshiftQueryEngineStorageTypePtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput() KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput + ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput +} + +type knowledgeBaseRedshiftQueryEngineStorageTypePtr string + +func KnowledgeBaseRedshiftQueryEngineStorageTypePtr(v string) KnowledgeBaseRedshiftQueryEngineStorageTypePtrInput { + return (*knowledgeBaseRedshiftQueryEngineStorageTypePtr)(&v) +} + +func (*knowledgeBaseRedshiftQueryEngineStorageTypePtr) ElementType() reflect.Type { + return knowledgeBaseRedshiftQueryEngineStorageTypePtrType +} + +func (in *knowledgeBaseRedshiftQueryEngineStorageTypePtr) ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput() KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput { + return pulumi.ToOutput(in).(KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) +} + +func (in *knowledgeBaseRedshiftQueryEngineStorageTypePtr) ToKnowledgeBaseRedshiftQueryEngineStorageTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput) +} + +// Redshift query engine type +type KnowledgeBaseRedshiftQueryEngineType string + +const ( + KnowledgeBaseRedshiftQueryEngineTypeServerless = KnowledgeBaseRedshiftQueryEngineType("SERVERLESS") + KnowledgeBaseRedshiftQueryEngineTypeProvisioned = KnowledgeBaseRedshiftQueryEngineType("PROVISIONED") +) + +func (KnowledgeBaseRedshiftQueryEngineType) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineType)(nil)).Elem() +} + +func (e KnowledgeBaseRedshiftQueryEngineType) ToKnowledgeBaseRedshiftQueryEngineTypeOutput() KnowledgeBaseRedshiftQueryEngineTypeOutput { + return pulumi.ToOutput(e).(KnowledgeBaseRedshiftQueryEngineTypeOutput) +} + +func (e KnowledgeBaseRedshiftQueryEngineType) ToKnowledgeBaseRedshiftQueryEngineTypeOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineTypeOutput { + return pulumi.ToOutputWithContext(ctx, e).(KnowledgeBaseRedshiftQueryEngineTypeOutput) +} + +func (e KnowledgeBaseRedshiftQueryEngineType) ToKnowledgeBaseRedshiftQueryEngineTypePtrOutput() KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return e.ToKnowledgeBaseRedshiftQueryEngineTypePtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseRedshiftQueryEngineType) ToKnowledgeBaseRedshiftQueryEngineTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return KnowledgeBaseRedshiftQueryEngineType(e).ToKnowledgeBaseRedshiftQueryEngineTypeOutputWithContext(ctx).ToKnowledgeBaseRedshiftQueryEngineTypePtrOutputWithContext(ctx) +} + +func (e KnowledgeBaseRedshiftQueryEngineType) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseRedshiftQueryEngineType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseRedshiftQueryEngineType) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseRedshiftQueryEngineType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type KnowledgeBaseRedshiftQueryEngineTypeOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineType)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineTypeOutput) ToKnowledgeBaseRedshiftQueryEngineTypeOutput() KnowledgeBaseRedshiftQueryEngineTypeOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineTypeOutput) ToKnowledgeBaseRedshiftQueryEngineTypeOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineTypeOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineTypeOutput) ToKnowledgeBaseRedshiftQueryEngineTypePtrOutput() KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return o.ToKnowledgeBaseRedshiftQueryEngineTypePtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineTypeOutput) ToKnowledgeBaseRedshiftQueryEngineTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftQueryEngineType) *KnowledgeBaseRedshiftQueryEngineType { + return &v + }).(KnowledgeBaseRedshiftQueryEngineTypePtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseRedshiftQueryEngineType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseRedshiftQueryEngineType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseRedshiftQueryEngineTypePtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineType)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineTypePtrOutput) ToKnowledgeBaseRedshiftQueryEngineTypePtrOutput() KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineTypePtrOutput) ToKnowledgeBaseRedshiftQueryEngineTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineTypePtrOutput) Elem() KnowledgeBaseRedshiftQueryEngineTypeOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineType) KnowledgeBaseRedshiftQueryEngineType { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftQueryEngineType + return ret + }).(KnowledgeBaseRedshiftQueryEngineTypeOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *KnowledgeBaseRedshiftQueryEngineType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// KnowledgeBaseRedshiftQueryEngineTypeInput is an input type that accepts values of the KnowledgeBaseRedshiftQueryEngineType enum +// A concrete instance of `KnowledgeBaseRedshiftQueryEngineTypeInput` can be one of the following: +// +// KnowledgeBaseRedshiftQueryEngineTypeServerless +// KnowledgeBaseRedshiftQueryEngineTypeProvisioned +type KnowledgeBaseRedshiftQueryEngineTypeInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineTypeOutput() KnowledgeBaseRedshiftQueryEngineTypeOutput + ToKnowledgeBaseRedshiftQueryEngineTypeOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineTypeOutput +} + +var knowledgeBaseRedshiftQueryEngineTypePtrType = reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineType)(nil)).Elem() + +type KnowledgeBaseRedshiftQueryEngineTypePtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineTypePtrOutput() KnowledgeBaseRedshiftQueryEngineTypePtrOutput + ToKnowledgeBaseRedshiftQueryEngineTypePtrOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineTypePtrOutput +} + +type knowledgeBaseRedshiftQueryEngineTypePtr string + +func KnowledgeBaseRedshiftQueryEngineTypePtr(v string) KnowledgeBaseRedshiftQueryEngineTypePtrInput { + return (*knowledgeBaseRedshiftQueryEngineTypePtr)(&v) +} + +func (*knowledgeBaseRedshiftQueryEngineTypePtr) ElementType() reflect.Type { + return knowledgeBaseRedshiftQueryEngineTypePtrType +} + +func (in *knowledgeBaseRedshiftQueryEngineTypePtr) ToKnowledgeBaseRedshiftQueryEngineTypePtrOutput() KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return pulumi.ToOutput(in).(KnowledgeBaseRedshiftQueryEngineTypePtrOutput) +} + +func (in *knowledgeBaseRedshiftQueryEngineTypePtr) ToKnowledgeBaseRedshiftQueryEngineTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(KnowledgeBaseRedshiftQueryEngineTypePtrOutput) +} + +// Serverless Redshift auth type +type KnowledgeBaseRedshiftServerlessAuthType string + +const ( + KnowledgeBaseRedshiftServerlessAuthTypeIam = KnowledgeBaseRedshiftServerlessAuthType("IAM") + KnowledgeBaseRedshiftServerlessAuthTypeUsernamePassword = KnowledgeBaseRedshiftServerlessAuthType("USERNAME_PASSWORD") +) + +func (KnowledgeBaseRedshiftServerlessAuthType) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftServerlessAuthType)(nil)).Elem() +} + +func (e KnowledgeBaseRedshiftServerlessAuthType) ToKnowledgeBaseRedshiftServerlessAuthTypeOutput() KnowledgeBaseRedshiftServerlessAuthTypeOutput { + return pulumi.ToOutput(e).(KnowledgeBaseRedshiftServerlessAuthTypeOutput) +} + +func (e KnowledgeBaseRedshiftServerlessAuthType) ToKnowledgeBaseRedshiftServerlessAuthTypeOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthTypeOutput { + return pulumi.ToOutputWithContext(ctx, e).(KnowledgeBaseRedshiftServerlessAuthTypeOutput) +} + +func (e KnowledgeBaseRedshiftServerlessAuthType) ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutput() KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return e.ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseRedshiftServerlessAuthType) ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return KnowledgeBaseRedshiftServerlessAuthType(e).ToKnowledgeBaseRedshiftServerlessAuthTypeOutputWithContext(ctx).ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutputWithContext(ctx) +} + +func (e KnowledgeBaseRedshiftServerlessAuthType) ToStringOutput() pulumi.StringOutput { + return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseRedshiftServerlessAuthType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput) +} + +func (e KnowledgeBaseRedshiftServerlessAuthType) ToStringPtrOutput() pulumi.StringPtrOutput { + return pulumi.String(e).ToStringPtrOutputWithContext(context.Background()) +} + +func (e KnowledgeBaseRedshiftServerlessAuthType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx) +} + +type KnowledgeBaseRedshiftServerlessAuthTypeOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftServerlessAuthTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftServerlessAuthType)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypeOutput) ToKnowledgeBaseRedshiftServerlessAuthTypeOutput() KnowledgeBaseRedshiftServerlessAuthTypeOutput { + return o +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypeOutput) ToKnowledgeBaseRedshiftServerlessAuthTypeOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthTypeOutput { + return o +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypeOutput) ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutput() KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return o.ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypeOutput) ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftServerlessAuthType) *KnowledgeBaseRedshiftServerlessAuthType { + return &v + }).(KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypeOutput) ToStringOutput() pulumi.StringOutput { + return o.ToStringOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseRedshiftServerlessAuthType) string { + return string(e) + }).(pulumi.StringOutput) +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e KnowledgeBaseRedshiftServerlessAuthType) *string { + v := string(e) + return &v + }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseRedshiftServerlessAuthTypePtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftServerlessAuthType)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutput() KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) Elem() KnowledgeBaseRedshiftServerlessAuthTypeOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftServerlessAuthType) KnowledgeBaseRedshiftServerlessAuthType { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftServerlessAuthType + return ret + }).(KnowledgeBaseRedshiftServerlessAuthTypeOutput) +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput { + return o.ToStringPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, e *KnowledgeBaseRedshiftServerlessAuthType) *string { + if e == nil { + return nil + } + v := string(*e) + return &v + }).(pulumi.StringPtrOutput) +} + +// KnowledgeBaseRedshiftServerlessAuthTypeInput is an input type that accepts values of the KnowledgeBaseRedshiftServerlessAuthType enum +// A concrete instance of `KnowledgeBaseRedshiftServerlessAuthTypeInput` can be one of the following: +// +// KnowledgeBaseRedshiftServerlessAuthTypeIam +// KnowledgeBaseRedshiftServerlessAuthTypeUsernamePassword +type KnowledgeBaseRedshiftServerlessAuthTypeInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftServerlessAuthTypeOutput() KnowledgeBaseRedshiftServerlessAuthTypeOutput + ToKnowledgeBaseRedshiftServerlessAuthTypeOutputWithContext(context.Context) KnowledgeBaseRedshiftServerlessAuthTypeOutput +} + +var knowledgeBaseRedshiftServerlessAuthTypePtrType = reflect.TypeOf((**KnowledgeBaseRedshiftServerlessAuthType)(nil)).Elem() + +type KnowledgeBaseRedshiftServerlessAuthTypePtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutput() KnowledgeBaseRedshiftServerlessAuthTypePtrOutput + ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutputWithContext(context.Context) KnowledgeBaseRedshiftServerlessAuthTypePtrOutput +} + +type knowledgeBaseRedshiftServerlessAuthTypePtr string + +func KnowledgeBaseRedshiftServerlessAuthTypePtr(v string) KnowledgeBaseRedshiftServerlessAuthTypePtrInput { + return (*knowledgeBaseRedshiftServerlessAuthTypePtr)(&v) +} + +func (*knowledgeBaseRedshiftServerlessAuthTypePtr) ElementType() reflect.Type { + return knowledgeBaseRedshiftServerlessAuthTypePtrType +} + +func (in *knowledgeBaseRedshiftServerlessAuthTypePtr) ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutput() KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return pulumi.ToOutput(in).(KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) +} + +func (in *knowledgeBaseRedshiftServerlessAuthTypePtr) ToKnowledgeBaseRedshiftServerlessAuthTypePtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, in).(KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) +} + // The status of a knowledge base. type KnowledgeBaseStatus string @@ -7140,6 +8138,7 @@ type KnowledgeBaseType string const ( KnowledgeBaseTypeVector = KnowledgeBaseType("VECTOR") KnowledgeBaseTypeKendra = KnowledgeBaseType("KENDRA") + KnowledgeBaseTypeSql = KnowledgeBaseType("SQL") ) func (KnowledgeBaseType) ElementType() reflect.Type { @@ -7266,6 +8265,7 @@ func (o KnowledgeBaseTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Con // // KnowledgeBaseTypeVector // KnowledgeBaseTypeKendra +// KnowledgeBaseTypeSql type KnowledgeBaseTypeInput interface { pulumi.Input @@ -7789,6 +8789,18 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*GuardrailSensitiveInformationActionPtrInput)(nil)).Elem(), GuardrailSensitiveInformationAction("BLOCK")) pulumi.RegisterInputType(reflect.TypeOf((*GuardrailTopicTypeInput)(nil)).Elem(), GuardrailTopicType("DENY")) pulumi.RegisterInputType(reflect.TypeOf((*GuardrailTopicTypePtrInput)(nil)).Elem(), GuardrailTopicType("DENY")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseInclusionTypeInput)(nil)).Elem(), KnowledgeBaseInclusionType("INCLUDE")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseInclusionTypePtrInput)(nil)).Elem(), KnowledgeBaseInclusionType("INCLUDE")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryEngineTypeInput)(nil)).Elem(), KnowledgeBaseQueryEngineType("REDSHIFT")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryEngineTypePtrInput)(nil)).Elem(), KnowledgeBaseQueryEngineType("REDSHIFT")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedAuthTypeInput)(nil)).Elem(), KnowledgeBaseRedshiftProvisionedAuthType("IAM")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedAuthTypePtrInput)(nil)).Elem(), KnowledgeBaseRedshiftProvisionedAuthType("IAM")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineStorageTypeInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineStorageType("REDSHIFT")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineStorageTypePtrInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineStorageType("REDSHIFT")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineTypeInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineType("SERVERLESS")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineTypePtrInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineType("SERVERLESS")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftServerlessAuthTypeInput)(nil)).Elem(), KnowledgeBaseRedshiftServerlessAuthType("IAM")) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftServerlessAuthTypePtrInput)(nil)).Elem(), KnowledgeBaseRedshiftServerlessAuthType("IAM")) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseStorageTypeInput)(nil)).Elem(), KnowledgeBaseStorageType("OPENSEARCH_SERVERLESS")) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseStorageTypePtrInput)(nil)).Elem(), KnowledgeBaseStorageType("OPENSEARCH_SERVERLESS")) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseSupplementalDataStorageLocationTypeInput)(nil)).Elem(), KnowledgeBaseSupplementalDataStorageLocationType("S3")) @@ -7889,6 +8901,18 @@ func init() { pulumi.RegisterOutputType(GuardrailStatusPtrOutput{}) pulumi.RegisterOutputType(GuardrailTopicTypeOutput{}) pulumi.RegisterOutputType(GuardrailTopicTypePtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseInclusionTypeOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseInclusionTypePtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryEngineTypeOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryEngineTypePtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftProvisionedAuthTypeOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineStorageTypeOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineStorageTypePtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineTypeOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineTypePtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftServerlessAuthTypeOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftServerlessAuthTypePtrOutput{}) pulumi.RegisterOutputType(KnowledgeBaseStatusOutput{}) pulumi.RegisterOutputType(KnowledgeBaseStatusPtrOutput{}) pulumi.RegisterOutputType(KnowledgeBaseStorageTypeOutput{}) diff --git a/sdk/go/aws/bedrock/pulumiTypes.go b/sdk/go/aws/bedrock/pulumiTypes.go index d1183c279f..9c78fd3e62 100644 --- a/sdk/go/aws/bedrock/pulumiTypes.go +++ b/sdk/go/aws/bedrock/pulumiTypes.go @@ -20255,6 +20255,7 @@ func (o KnowledgeBaseBedrockEmbeddingModelConfigurationPtrOutput) Dimensions() p type KnowledgeBaseConfiguration struct { // Settings for an Amazon Kendra knowledge base. KendraKnowledgeBaseConfiguration *KnowledgeBaseKendraKnowledgeBaseConfiguration `pulumi:"kendraKnowledgeBaseConfiguration"` + SqlKnowledgeBaseConfiguration *KnowledgeBaseSqlKnowledgeBaseConfiguration `pulumi:"sqlKnowledgeBaseConfiguration"` // The type of data that the data source is converted into for the knowledge base. Type KnowledgeBaseType `pulumi:"type"` // Contains details about the model that's used to convert the data source into vector embeddings. @@ -20276,6 +20277,7 @@ type KnowledgeBaseConfigurationInput interface { type KnowledgeBaseConfigurationArgs struct { // Settings for an Amazon Kendra knowledge base. KendraKnowledgeBaseConfiguration KnowledgeBaseKendraKnowledgeBaseConfigurationPtrInput `pulumi:"kendraKnowledgeBaseConfiguration"` + SqlKnowledgeBaseConfiguration KnowledgeBaseSqlKnowledgeBaseConfigurationPtrInput `pulumi:"sqlKnowledgeBaseConfiguration"` // The type of data that the data source is converted into for the knowledge base. Type KnowledgeBaseTypeInput `pulumi:"type"` // Contains details about the model that's used to convert the data source into vector embeddings. @@ -20316,6 +20318,12 @@ func (o KnowledgeBaseConfigurationOutput) KendraKnowledgeBaseConfiguration() Kno }).(KnowledgeBaseKendraKnowledgeBaseConfigurationPtrOutput) } +func (o KnowledgeBaseConfigurationOutput) SqlKnowledgeBaseConfiguration() KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return o.ApplyT(func(v KnowledgeBaseConfiguration) *KnowledgeBaseSqlKnowledgeBaseConfiguration { + return v.SqlKnowledgeBaseConfiguration + }).(KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) +} + // The type of data that the data source is converted into for the knowledge base. func (o KnowledgeBaseConfigurationOutput) Type() KnowledgeBaseTypeOutput { return o.ApplyT(func(v KnowledgeBaseConfiguration) KnowledgeBaseType { return v.Type }).(KnowledgeBaseTypeOutput) @@ -20328,6 +20336,172 @@ func (o KnowledgeBaseConfigurationOutput) VectorKnowledgeBaseConfiguration() Kno }).(KnowledgeBaseVectorKnowledgeBaseConfigurationPtrOutput) } +type KnowledgeBaseConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseConfigurationPtrOutput) ToKnowledgeBaseConfigurationPtrOutput() KnowledgeBaseConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseConfigurationPtrOutput) ToKnowledgeBaseConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseConfigurationPtrOutput) Elem() KnowledgeBaseConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseConfiguration) KnowledgeBaseConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseConfiguration + return ret + }).(KnowledgeBaseConfigurationOutput) +} + +// Settings for an Amazon Kendra knowledge base. +func (o KnowledgeBaseConfigurationPtrOutput) KendraKnowledgeBaseConfiguration() KnowledgeBaseKendraKnowledgeBaseConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseConfiguration) *KnowledgeBaseKendraKnowledgeBaseConfiguration { + if v == nil { + return nil + } + return v.KendraKnowledgeBaseConfiguration + }).(KnowledgeBaseKendraKnowledgeBaseConfigurationPtrOutput) +} + +func (o KnowledgeBaseConfigurationPtrOutput) SqlKnowledgeBaseConfiguration() KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseConfiguration) *KnowledgeBaseSqlKnowledgeBaseConfiguration { + if v == nil { + return nil + } + return v.SqlKnowledgeBaseConfiguration + }).(KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) +} + +// The type of data that the data source is converted into for the knowledge base. +func (o KnowledgeBaseConfigurationPtrOutput) Type() KnowledgeBaseTypePtrOutput { + return o.ApplyT(func(v *KnowledgeBaseConfiguration) *KnowledgeBaseType { + if v == nil { + return nil + } + return &v.Type + }).(KnowledgeBaseTypePtrOutput) +} + +// Contains details about the model that's used to convert the data source into vector embeddings. +func (o KnowledgeBaseConfigurationPtrOutput) VectorKnowledgeBaseConfiguration() KnowledgeBaseVectorKnowledgeBaseConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseConfiguration) *KnowledgeBaseVectorKnowledgeBaseConfiguration { + if v == nil { + return nil + } + return v.VectorKnowledgeBaseConfiguration + }).(KnowledgeBaseVectorKnowledgeBaseConfigurationPtrOutput) +} + +// Curated query or question and answer pair +type KnowledgeBaseCuratedQuery struct { + NaturalLanguage string `pulumi:"naturalLanguage"` + Sql string `pulumi:"sql"` +} + +// KnowledgeBaseCuratedQueryInput is an input type that accepts KnowledgeBaseCuratedQueryArgs and KnowledgeBaseCuratedQueryOutput values. +// You can construct a concrete instance of `KnowledgeBaseCuratedQueryInput` via: +// +// KnowledgeBaseCuratedQueryArgs{...} +type KnowledgeBaseCuratedQueryInput interface { + pulumi.Input + + ToKnowledgeBaseCuratedQueryOutput() KnowledgeBaseCuratedQueryOutput + ToKnowledgeBaseCuratedQueryOutputWithContext(context.Context) KnowledgeBaseCuratedQueryOutput +} + +// Curated query or question and answer pair +type KnowledgeBaseCuratedQueryArgs struct { + NaturalLanguage pulumi.StringInput `pulumi:"naturalLanguage"` + Sql pulumi.StringInput `pulumi:"sql"` +} + +func (KnowledgeBaseCuratedQueryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseCuratedQuery)(nil)).Elem() +} + +func (i KnowledgeBaseCuratedQueryArgs) ToKnowledgeBaseCuratedQueryOutput() KnowledgeBaseCuratedQueryOutput { + return i.ToKnowledgeBaseCuratedQueryOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseCuratedQueryArgs) ToKnowledgeBaseCuratedQueryOutputWithContext(ctx context.Context) KnowledgeBaseCuratedQueryOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseCuratedQueryOutput) +} + +// KnowledgeBaseCuratedQueryArrayInput is an input type that accepts KnowledgeBaseCuratedQueryArray and KnowledgeBaseCuratedQueryArrayOutput values. +// You can construct a concrete instance of `KnowledgeBaseCuratedQueryArrayInput` via: +// +// KnowledgeBaseCuratedQueryArray{ KnowledgeBaseCuratedQueryArgs{...} } +type KnowledgeBaseCuratedQueryArrayInput interface { + pulumi.Input + + ToKnowledgeBaseCuratedQueryArrayOutput() KnowledgeBaseCuratedQueryArrayOutput + ToKnowledgeBaseCuratedQueryArrayOutputWithContext(context.Context) KnowledgeBaseCuratedQueryArrayOutput +} + +type KnowledgeBaseCuratedQueryArray []KnowledgeBaseCuratedQueryInput + +func (KnowledgeBaseCuratedQueryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]KnowledgeBaseCuratedQuery)(nil)).Elem() +} + +func (i KnowledgeBaseCuratedQueryArray) ToKnowledgeBaseCuratedQueryArrayOutput() KnowledgeBaseCuratedQueryArrayOutput { + return i.ToKnowledgeBaseCuratedQueryArrayOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseCuratedQueryArray) ToKnowledgeBaseCuratedQueryArrayOutputWithContext(ctx context.Context) KnowledgeBaseCuratedQueryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseCuratedQueryArrayOutput) +} + +// Curated query or question and answer pair +type KnowledgeBaseCuratedQueryOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseCuratedQueryOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseCuratedQuery)(nil)).Elem() +} + +func (o KnowledgeBaseCuratedQueryOutput) ToKnowledgeBaseCuratedQueryOutput() KnowledgeBaseCuratedQueryOutput { + return o +} + +func (o KnowledgeBaseCuratedQueryOutput) ToKnowledgeBaseCuratedQueryOutputWithContext(ctx context.Context) KnowledgeBaseCuratedQueryOutput { + return o +} + +func (o KnowledgeBaseCuratedQueryOutput) NaturalLanguage() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseCuratedQuery) string { return v.NaturalLanguage }).(pulumi.StringOutput) +} + +func (o KnowledgeBaseCuratedQueryOutput) Sql() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseCuratedQuery) string { return v.Sql }).(pulumi.StringOutput) +} + +type KnowledgeBaseCuratedQueryArrayOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseCuratedQueryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]KnowledgeBaseCuratedQuery)(nil)).Elem() +} + +func (o KnowledgeBaseCuratedQueryArrayOutput) ToKnowledgeBaseCuratedQueryArrayOutput() KnowledgeBaseCuratedQueryArrayOutput { + return o +} + +func (o KnowledgeBaseCuratedQueryArrayOutput) ToKnowledgeBaseCuratedQueryArrayOutputWithContext(ctx context.Context) KnowledgeBaseCuratedQueryArrayOutput { + return o +} + +func (o KnowledgeBaseCuratedQueryArrayOutput) Index(i pulumi.IntInput) KnowledgeBaseCuratedQueryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) KnowledgeBaseCuratedQuery { + return vs[0].([]KnowledgeBaseCuratedQuery)[vs[1].(int)] + }).(KnowledgeBaseCuratedQueryOutput) +} + // The embeddings model configuration details for the vector model used in Knowledge Base. type KnowledgeBaseEmbeddingModelConfiguration struct { // The vector configuration details on the Bedrock embeddings model. @@ -21758,416 +21932,2308 @@ func (o KnowledgeBasePineconeFieldMappingPtrOutput) TextField() pulumi.StringPtr }).(pulumi.StringPtrOutput) } -// Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS. -type KnowledgeBaseRdsConfiguration struct { - // The ARN of the secret that you created in AWS Secrets Manager that is linked to your Amazon RDS database. - CredentialsSecretArn string `pulumi:"credentialsSecretArn"` - // The name of your Amazon RDS database. - DatabaseName string `pulumi:"databaseName"` - // Contains the names of the fields to which to map information about the vector store. - FieldMapping KnowledgeBaseRdsFieldMapping `pulumi:"fieldMapping"` - // The ARN of the vector store. - ResourceArn string `pulumi:"resourceArn"` - // The name of the table in the database. - TableName string `pulumi:"tableName"` +// Redshift query generation column +type KnowledgeBaseQueryGenerationColumn struct { + Description *string `pulumi:"description"` + Inclusion *KnowledgeBaseInclusionType `pulumi:"inclusion"` + Name *string `pulumi:"name"` } -// KnowledgeBaseRdsConfigurationInput is an input type that accepts KnowledgeBaseRdsConfigurationArgs and KnowledgeBaseRdsConfigurationOutput values. -// You can construct a concrete instance of `KnowledgeBaseRdsConfigurationInput` via: +// KnowledgeBaseQueryGenerationColumnInput is an input type that accepts KnowledgeBaseQueryGenerationColumnArgs and KnowledgeBaseQueryGenerationColumnOutput values. +// You can construct a concrete instance of `KnowledgeBaseQueryGenerationColumnInput` via: // -// KnowledgeBaseRdsConfigurationArgs{...} -type KnowledgeBaseRdsConfigurationInput interface { +// KnowledgeBaseQueryGenerationColumnArgs{...} +type KnowledgeBaseQueryGenerationColumnInput interface { pulumi.Input - ToKnowledgeBaseRdsConfigurationOutput() KnowledgeBaseRdsConfigurationOutput - ToKnowledgeBaseRdsConfigurationOutputWithContext(context.Context) KnowledgeBaseRdsConfigurationOutput + ToKnowledgeBaseQueryGenerationColumnOutput() KnowledgeBaseQueryGenerationColumnOutput + ToKnowledgeBaseQueryGenerationColumnOutputWithContext(context.Context) KnowledgeBaseQueryGenerationColumnOutput } -// Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS. -type KnowledgeBaseRdsConfigurationArgs struct { - // The ARN of the secret that you created in AWS Secrets Manager that is linked to your Amazon RDS database. - CredentialsSecretArn pulumi.StringInput `pulumi:"credentialsSecretArn"` - // The name of your Amazon RDS database. - DatabaseName pulumi.StringInput `pulumi:"databaseName"` - // Contains the names of the fields to which to map information about the vector store. - FieldMapping KnowledgeBaseRdsFieldMappingInput `pulumi:"fieldMapping"` - // The ARN of the vector store. - ResourceArn pulumi.StringInput `pulumi:"resourceArn"` - // The name of the table in the database. - TableName pulumi.StringInput `pulumi:"tableName"` +// Redshift query generation column +type KnowledgeBaseQueryGenerationColumnArgs struct { + Description pulumi.StringPtrInput `pulumi:"description"` + Inclusion KnowledgeBaseInclusionTypePtrInput `pulumi:"inclusion"` + Name pulumi.StringPtrInput `pulumi:"name"` } -func (KnowledgeBaseRdsConfigurationArgs) ElementType() reflect.Type { - return reflect.TypeOf((*KnowledgeBaseRdsConfiguration)(nil)).Elem() +func (KnowledgeBaseQueryGenerationColumnArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryGenerationColumn)(nil)).Elem() } -func (i KnowledgeBaseRdsConfigurationArgs) ToKnowledgeBaseRdsConfigurationOutput() KnowledgeBaseRdsConfigurationOutput { - return i.ToKnowledgeBaseRdsConfigurationOutputWithContext(context.Background()) +func (i KnowledgeBaseQueryGenerationColumnArgs) ToKnowledgeBaseQueryGenerationColumnOutput() KnowledgeBaseQueryGenerationColumnOutput { + return i.ToKnowledgeBaseQueryGenerationColumnOutputWithContext(context.Background()) } -func (i KnowledgeBaseRdsConfigurationArgs) ToKnowledgeBaseRdsConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationOutput { - return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsConfigurationOutput) +func (i KnowledgeBaseQueryGenerationColumnArgs) ToKnowledgeBaseQueryGenerationColumnOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationColumnOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationColumnOutput) } -func (i KnowledgeBaseRdsConfigurationArgs) ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput { - return i.ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(context.Background()) +// KnowledgeBaseQueryGenerationColumnArrayInput is an input type that accepts KnowledgeBaseQueryGenerationColumnArray and KnowledgeBaseQueryGenerationColumnArrayOutput values. +// You can construct a concrete instance of `KnowledgeBaseQueryGenerationColumnArrayInput` via: +// +// KnowledgeBaseQueryGenerationColumnArray{ KnowledgeBaseQueryGenerationColumnArgs{...} } +type KnowledgeBaseQueryGenerationColumnArrayInput interface { + pulumi.Input + + ToKnowledgeBaseQueryGenerationColumnArrayOutput() KnowledgeBaseQueryGenerationColumnArrayOutput + ToKnowledgeBaseQueryGenerationColumnArrayOutputWithContext(context.Context) KnowledgeBaseQueryGenerationColumnArrayOutput } -func (i KnowledgeBaseRdsConfigurationArgs) ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsConfigurationOutput).ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx) +type KnowledgeBaseQueryGenerationColumnArray []KnowledgeBaseQueryGenerationColumnInput + +func (KnowledgeBaseQueryGenerationColumnArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]KnowledgeBaseQueryGenerationColumn)(nil)).Elem() } -// KnowledgeBaseRdsConfigurationPtrInput is an input type that accepts KnowledgeBaseRdsConfigurationArgs, KnowledgeBaseRdsConfigurationPtr and KnowledgeBaseRdsConfigurationPtrOutput values. -// You can construct a concrete instance of `KnowledgeBaseRdsConfigurationPtrInput` via: +func (i KnowledgeBaseQueryGenerationColumnArray) ToKnowledgeBaseQueryGenerationColumnArrayOutput() KnowledgeBaseQueryGenerationColumnArrayOutput { + return i.ToKnowledgeBaseQueryGenerationColumnArrayOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseQueryGenerationColumnArray) ToKnowledgeBaseQueryGenerationColumnArrayOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationColumnArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationColumnArrayOutput) +} + +// Redshift query generation column +type KnowledgeBaseQueryGenerationColumnOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseQueryGenerationColumnOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryGenerationColumn)(nil)).Elem() +} + +func (o KnowledgeBaseQueryGenerationColumnOutput) ToKnowledgeBaseQueryGenerationColumnOutput() KnowledgeBaseQueryGenerationColumnOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationColumnOutput) ToKnowledgeBaseQueryGenerationColumnOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationColumnOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationColumnOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationColumn) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o KnowledgeBaseQueryGenerationColumnOutput) Inclusion() KnowledgeBaseInclusionTypePtrOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationColumn) *KnowledgeBaseInclusionType { return v.Inclusion }).(KnowledgeBaseInclusionTypePtrOutput) +} + +func (o KnowledgeBaseQueryGenerationColumnOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationColumn) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseQueryGenerationColumnArrayOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseQueryGenerationColumnArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]KnowledgeBaseQueryGenerationColumn)(nil)).Elem() +} + +func (o KnowledgeBaseQueryGenerationColumnArrayOutput) ToKnowledgeBaseQueryGenerationColumnArrayOutput() KnowledgeBaseQueryGenerationColumnArrayOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationColumnArrayOutput) ToKnowledgeBaseQueryGenerationColumnArrayOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationColumnArrayOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationColumnArrayOutput) Index(i pulumi.IntInput) KnowledgeBaseQueryGenerationColumnOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) KnowledgeBaseQueryGenerationColumn { + return vs[0].([]KnowledgeBaseQueryGenerationColumn)[vs[1].(int)] + }).(KnowledgeBaseQueryGenerationColumnOutput) +} + +// Configurations for generating Redshift engine queries +type KnowledgeBaseQueryGenerationConfiguration struct { + ExecutionTimeoutSeconds *int `pulumi:"executionTimeoutSeconds"` + GenerationContext *KnowledgeBaseQueryGenerationContext `pulumi:"generationContext"` +} + +// KnowledgeBaseQueryGenerationConfigurationInput is an input type that accepts KnowledgeBaseQueryGenerationConfigurationArgs and KnowledgeBaseQueryGenerationConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseQueryGenerationConfigurationInput` via: // -// KnowledgeBaseRdsConfigurationArgs{...} +// KnowledgeBaseQueryGenerationConfigurationArgs{...} +type KnowledgeBaseQueryGenerationConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseQueryGenerationConfigurationOutput() KnowledgeBaseQueryGenerationConfigurationOutput + ToKnowledgeBaseQueryGenerationConfigurationOutputWithContext(context.Context) KnowledgeBaseQueryGenerationConfigurationOutput +} + +// Configurations for generating Redshift engine queries +type KnowledgeBaseQueryGenerationConfigurationArgs struct { + ExecutionTimeoutSeconds pulumi.IntPtrInput `pulumi:"executionTimeoutSeconds"` + GenerationContext KnowledgeBaseQueryGenerationContextPtrInput `pulumi:"generationContext"` +} + +func (KnowledgeBaseQueryGenerationConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryGenerationConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseQueryGenerationConfigurationArgs) ToKnowledgeBaseQueryGenerationConfigurationOutput() KnowledgeBaseQueryGenerationConfigurationOutput { + return i.ToKnowledgeBaseQueryGenerationConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseQueryGenerationConfigurationArgs) ToKnowledgeBaseQueryGenerationConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationConfigurationOutput) +} + +func (i KnowledgeBaseQueryGenerationConfigurationArgs) ToKnowledgeBaseQueryGenerationConfigurationPtrOutput() KnowledgeBaseQueryGenerationConfigurationPtrOutput { + return i.ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseQueryGenerationConfigurationArgs) ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationConfigurationOutput).ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseQueryGenerationConfigurationPtrInput is an input type that accepts KnowledgeBaseQueryGenerationConfigurationArgs, KnowledgeBaseQueryGenerationConfigurationPtr and KnowledgeBaseQueryGenerationConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseQueryGenerationConfigurationPtrInput` via: +// +// KnowledgeBaseQueryGenerationConfigurationArgs{...} // // or: // // nil -type KnowledgeBaseRdsConfigurationPtrInput interface { +type KnowledgeBaseQueryGenerationConfigurationPtrInput interface { pulumi.Input - ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput - ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRdsConfigurationPtrOutput + ToKnowledgeBaseQueryGenerationConfigurationPtrOutput() KnowledgeBaseQueryGenerationConfigurationPtrOutput + ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseQueryGenerationConfigurationPtrOutput } -type knowledgeBaseRdsConfigurationPtrType KnowledgeBaseRdsConfigurationArgs +type knowledgeBaseQueryGenerationConfigurationPtrType KnowledgeBaseQueryGenerationConfigurationArgs -func KnowledgeBaseRdsConfigurationPtr(v *KnowledgeBaseRdsConfigurationArgs) KnowledgeBaseRdsConfigurationPtrInput { - return (*knowledgeBaseRdsConfigurationPtrType)(v) +func KnowledgeBaseQueryGenerationConfigurationPtr(v *KnowledgeBaseQueryGenerationConfigurationArgs) KnowledgeBaseQueryGenerationConfigurationPtrInput { + return (*knowledgeBaseQueryGenerationConfigurationPtrType)(v) } -func (*knowledgeBaseRdsConfigurationPtrType) ElementType() reflect.Type { - return reflect.TypeOf((**KnowledgeBaseRdsConfiguration)(nil)).Elem() +func (*knowledgeBaseQueryGenerationConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseQueryGenerationConfiguration)(nil)).Elem() } -func (i *knowledgeBaseRdsConfigurationPtrType) ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput { - return i.ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(context.Background()) +func (i *knowledgeBaseQueryGenerationConfigurationPtrType) ToKnowledgeBaseQueryGenerationConfigurationPtrOutput() KnowledgeBaseQueryGenerationConfigurationPtrOutput { + return i.ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(context.Background()) } -func (i *knowledgeBaseRdsConfigurationPtrType) ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsConfigurationPtrOutput) +func (i *knowledgeBaseQueryGenerationConfigurationPtrType) ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationConfigurationPtrOutput) } -// Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS. -type KnowledgeBaseRdsConfigurationOutput struct{ *pulumi.OutputState } +// Configurations for generating Redshift engine queries +type KnowledgeBaseQueryGenerationConfigurationOutput struct{ *pulumi.OutputState } -func (KnowledgeBaseRdsConfigurationOutput) ElementType() reflect.Type { - return reflect.TypeOf((*KnowledgeBaseRdsConfiguration)(nil)).Elem() +func (KnowledgeBaseQueryGenerationConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryGenerationConfiguration)(nil)).Elem() } -func (o KnowledgeBaseRdsConfigurationOutput) ToKnowledgeBaseRdsConfigurationOutput() KnowledgeBaseRdsConfigurationOutput { +func (o KnowledgeBaseQueryGenerationConfigurationOutput) ToKnowledgeBaseQueryGenerationConfigurationOutput() KnowledgeBaseQueryGenerationConfigurationOutput { return o } -func (o KnowledgeBaseRdsConfigurationOutput) ToKnowledgeBaseRdsConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationOutput { +func (o KnowledgeBaseQueryGenerationConfigurationOutput) ToKnowledgeBaseQueryGenerationConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationConfigurationOutput { return o } -func (o KnowledgeBaseRdsConfigurationOutput) ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput { - return o.ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(context.Background()) +func (o KnowledgeBaseQueryGenerationConfigurationOutput) ToKnowledgeBaseQueryGenerationConfigurationPtrOutput() KnowledgeBaseQueryGenerationConfigurationPtrOutput { + return o.ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(context.Background()) } -func (o KnowledgeBaseRdsConfigurationOutput) ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationPtrOutput { - return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRdsConfiguration) *KnowledgeBaseRdsConfiguration { +func (o KnowledgeBaseQueryGenerationConfigurationOutput) ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseQueryGenerationConfiguration) *KnowledgeBaseQueryGenerationConfiguration { return &v - }).(KnowledgeBaseRdsConfigurationPtrOutput) -} - -// The ARN of the secret that you created in AWS Secrets Manager that is linked to your Amazon RDS database. -func (o KnowledgeBaseRdsConfigurationOutput) CredentialsSecretArn() pulumi.StringOutput { - return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) string { return v.CredentialsSecretArn }).(pulumi.StringOutput) -} - -// The name of your Amazon RDS database. -func (o KnowledgeBaseRdsConfigurationOutput) DatabaseName() pulumi.StringOutput { - return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) string { return v.DatabaseName }).(pulumi.StringOutput) -} - -// Contains the names of the fields to which to map information about the vector store. -func (o KnowledgeBaseRdsConfigurationOutput) FieldMapping() KnowledgeBaseRdsFieldMappingOutput { - return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) KnowledgeBaseRdsFieldMapping { return v.FieldMapping }).(KnowledgeBaseRdsFieldMappingOutput) + }).(KnowledgeBaseQueryGenerationConfigurationPtrOutput) } -// The ARN of the vector store. -func (o KnowledgeBaseRdsConfigurationOutput) ResourceArn() pulumi.StringOutput { - return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) string { return v.ResourceArn }).(pulumi.StringOutput) +func (o KnowledgeBaseQueryGenerationConfigurationOutput) ExecutionTimeoutSeconds() pulumi.IntPtrOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationConfiguration) *int { return v.ExecutionTimeoutSeconds }).(pulumi.IntPtrOutput) } -// The name of the table in the database. -func (o KnowledgeBaseRdsConfigurationOutput) TableName() pulumi.StringOutput { - return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) string { return v.TableName }).(pulumi.StringOutput) +func (o KnowledgeBaseQueryGenerationConfigurationOutput) GenerationContext() KnowledgeBaseQueryGenerationContextPtrOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationConfiguration) *KnowledgeBaseQueryGenerationContext { + return v.GenerationContext + }).(KnowledgeBaseQueryGenerationContextPtrOutput) } -type KnowledgeBaseRdsConfigurationPtrOutput struct{ *pulumi.OutputState } +type KnowledgeBaseQueryGenerationConfigurationPtrOutput struct{ *pulumi.OutputState } -func (KnowledgeBaseRdsConfigurationPtrOutput) ElementType() reflect.Type { - return reflect.TypeOf((**KnowledgeBaseRdsConfiguration)(nil)).Elem() +func (KnowledgeBaseQueryGenerationConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseQueryGenerationConfiguration)(nil)).Elem() } -func (o KnowledgeBaseRdsConfigurationPtrOutput) ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput { +func (o KnowledgeBaseQueryGenerationConfigurationPtrOutput) ToKnowledgeBaseQueryGenerationConfigurationPtrOutput() KnowledgeBaseQueryGenerationConfigurationPtrOutput { return o } -func (o KnowledgeBaseRdsConfigurationPtrOutput) ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationPtrOutput { +func (o KnowledgeBaseQueryGenerationConfigurationPtrOutput) ToKnowledgeBaseQueryGenerationConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationConfigurationPtrOutput { return o } -func (o KnowledgeBaseRdsConfigurationPtrOutput) Elem() KnowledgeBaseRdsConfigurationOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) KnowledgeBaseRdsConfiguration { +func (o KnowledgeBaseQueryGenerationConfigurationPtrOutput) Elem() KnowledgeBaseQueryGenerationConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseQueryGenerationConfiguration) KnowledgeBaseQueryGenerationConfiguration { if v != nil { return *v } - var ret KnowledgeBaseRdsConfiguration + var ret KnowledgeBaseQueryGenerationConfiguration return ret - }).(KnowledgeBaseRdsConfigurationOutput) + }).(KnowledgeBaseQueryGenerationConfigurationOutput) } -// The ARN of the secret that you created in AWS Secrets Manager that is linked to your Amazon RDS database. -func (o KnowledgeBaseRdsConfigurationPtrOutput) CredentialsSecretArn() pulumi.StringPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *string { +func (o KnowledgeBaseQueryGenerationConfigurationPtrOutput) ExecutionTimeoutSeconds() pulumi.IntPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseQueryGenerationConfiguration) *int { if v == nil { return nil } - return &v.CredentialsSecretArn - }).(pulumi.StringPtrOutput) + return v.ExecutionTimeoutSeconds + }).(pulumi.IntPtrOutput) } -// The name of your Amazon RDS database. -func (o KnowledgeBaseRdsConfigurationPtrOutput) DatabaseName() pulumi.StringPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *string { +func (o KnowledgeBaseQueryGenerationConfigurationPtrOutput) GenerationContext() KnowledgeBaseQueryGenerationContextPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseQueryGenerationConfiguration) *KnowledgeBaseQueryGenerationContext { if v == nil { return nil } - return &v.DatabaseName - }).(pulumi.StringPtrOutput) + return v.GenerationContext + }).(KnowledgeBaseQueryGenerationContextPtrOutput) +} + +// Context used to improve query generation +type KnowledgeBaseQueryGenerationContext struct { + CuratedQueries []KnowledgeBaseCuratedQuery `pulumi:"curatedQueries"` + Tables []KnowledgeBaseQueryGenerationTable `pulumi:"tables"` +} + +// KnowledgeBaseQueryGenerationContextInput is an input type that accepts KnowledgeBaseQueryGenerationContextArgs and KnowledgeBaseQueryGenerationContextOutput values. +// You can construct a concrete instance of `KnowledgeBaseQueryGenerationContextInput` via: +// +// KnowledgeBaseQueryGenerationContextArgs{...} +type KnowledgeBaseQueryGenerationContextInput interface { + pulumi.Input + + ToKnowledgeBaseQueryGenerationContextOutput() KnowledgeBaseQueryGenerationContextOutput + ToKnowledgeBaseQueryGenerationContextOutputWithContext(context.Context) KnowledgeBaseQueryGenerationContextOutput +} + +// Context used to improve query generation +type KnowledgeBaseQueryGenerationContextArgs struct { + CuratedQueries KnowledgeBaseCuratedQueryArrayInput `pulumi:"curatedQueries"` + Tables KnowledgeBaseQueryGenerationTableArrayInput `pulumi:"tables"` +} + +func (KnowledgeBaseQueryGenerationContextArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryGenerationContext)(nil)).Elem() +} + +func (i KnowledgeBaseQueryGenerationContextArgs) ToKnowledgeBaseQueryGenerationContextOutput() KnowledgeBaseQueryGenerationContextOutput { + return i.ToKnowledgeBaseQueryGenerationContextOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseQueryGenerationContextArgs) ToKnowledgeBaseQueryGenerationContextOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationContextOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationContextOutput) +} + +func (i KnowledgeBaseQueryGenerationContextArgs) ToKnowledgeBaseQueryGenerationContextPtrOutput() KnowledgeBaseQueryGenerationContextPtrOutput { + return i.ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseQueryGenerationContextArgs) ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationContextPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationContextOutput).ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(ctx) +} + +// KnowledgeBaseQueryGenerationContextPtrInput is an input type that accepts KnowledgeBaseQueryGenerationContextArgs, KnowledgeBaseQueryGenerationContextPtr and KnowledgeBaseQueryGenerationContextPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseQueryGenerationContextPtrInput` via: +// +// KnowledgeBaseQueryGenerationContextArgs{...} +// +// or: +// +// nil +type KnowledgeBaseQueryGenerationContextPtrInput interface { + pulumi.Input + + ToKnowledgeBaseQueryGenerationContextPtrOutput() KnowledgeBaseQueryGenerationContextPtrOutput + ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(context.Context) KnowledgeBaseQueryGenerationContextPtrOutput +} + +type knowledgeBaseQueryGenerationContextPtrType KnowledgeBaseQueryGenerationContextArgs + +func KnowledgeBaseQueryGenerationContextPtr(v *KnowledgeBaseQueryGenerationContextArgs) KnowledgeBaseQueryGenerationContextPtrInput { + return (*knowledgeBaseQueryGenerationContextPtrType)(v) +} + +func (*knowledgeBaseQueryGenerationContextPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseQueryGenerationContext)(nil)).Elem() +} + +func (i *knowledgeBaseQueryGenerationContextPtrType) ToKnowledgeBaseQueryGenerationContextPtrOutput() KnowledgeBaseQueryGenerationContextPtrOutput { + return i.ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseQueryGenerationContextPtrType) ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationContextPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationContextPtrOutput) +} + +// Context used to improve query generation +type KnowledgeBaseQueryGenerationContextOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseQueryGenerationContextOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryGenerationContext)(nil)).Elem() +} + +func (o KnowledgeBaseQueryGenerationContextOutput) ToKnowledgeBaseQueryGenerationContextOutput() KnowledgeBaseQueryGenerationContextOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationContextOutput) ToKnowledgeBaseQueryGenerationContextOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationContextOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationContextOutput) ToKnowledgeBaseQueryGenerationContextPtrOutput() KnowledgeBaseQueryGenerationContextPtrOutput { + return o.ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseQueryGenerationContextOutput) ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationContextPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseQueryGenerationContext) *KnowledgeBaseQueryGenerationContext { + return &v + }).(KnowledgeBaseQueryGenerationContextPtrOutput) +} + +func (o KnowledgeBaseQueryGenerationContextOutput) CuratedQueries() KnowledgeBaseCuratedQueryArrayOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationContext) []KnowledgeBaseCuratedQuery { return v.CuratedQueries }).(KnowledgeBaseCuratedQueryArrayOutput) +} + +func (o KnowledgeBaseQueryGenerationContextOutput) Tables() KnowledgeBaseQueryGenerationTableArrayOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationContext) []KnowledgeBaseQueryGenerationTable { return v.Tables }).(KnowledgeBaseQueryGenerationTableArrayOutput) +} + +type KnowledgeBaseQueryGenerationContextPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseQueryGenerationContextPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseQueryGenerationContext)(nil)).Elem() +} + +func (o KnowledgeBaseQueryGenerationContextPtrOutput) ToKnowledgeBaseQueryGenerationContextPtrOutput() KnowledgeBaseQueryGenerationContextPtrOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationContextPtrOutput) ToKnowledgeBaseQueryGenerationContextPtrOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationContextPtrOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationContextPtrOutput) Elem() KnowledgeBaseQueryGenerationContextOutput { + return o.ApplyT(func(v *KnowledgeBaseQueryGenerationContext) KnowledgeBaseQueryGenerationContext { + if v != nil { + return *v + } + var ret KnowledgeBaseQueryGenerationContext + return ret + }).(KnowledgeBaseQueryGenerationContextOutput) +} + +func (o KnowledgeBaseQueryGenerationContextPtrOutput) CuratedQueries() KnowledgeBaseCuratedQueryArrayOutput { + return o.ApplyT(func(v *KnowledgeBaseQueryGenerationContext) []KnowledgeBaseCuratedQuery { + if v == nil { + return nil + } + return v.CuratedQueries + }).(KnowledgeBaseCuratedQueryArrayOutput) +} + +func (o KnowledgeBaseQueryGenerationContextPtrOutput) Tables() KnowledgeBaseQueryGenerationTableArrayOutput { + return o.ApplyT(func(v *KnowledgeBaseQueryGenerationContext) []KnowledgeBaseQueryGenerationTable { + if v == nil { + return nil + } + return v.Tables + }).(KnowledgeBaseQueryGenerationTableArrayOutput) +} + +// Tables used for Redshift query generation context +type KnowledgeBaseQueryGenerationTable struct { + Columns []KnowledgeBaseQueryGenerationColumn `pulumi:"columns"` + Description *string `pulumi:"description"` + Inclusion *KnowledgeBaseInclusionType `pulumi:"inclusion"` + Name string `pulumi:"name"` +} + +// KnowledgeBaseQueryGenerationTableInput is an input type that accepts KnowledgeBaseQueryGenerationTableArgs and KnowledgeBaseQueryGenerationTableOutput values. +// You can construct a concrete instance of `KnowledgeBaseQueryGenerationTableInput` via: +// +// KnowledgeBaseQueryGenerationTableArgs{...} +type KnowledgeBaseQueryGenerationTableInput interface { + pulumi.Input + + ToKnowledgeBaseQueryGenerationTableOutput() KnowledgeBaseQueryGenerationTableOutput + ToKnowledgeBaseQueryGenerationTableOutputWithContext(context.Context) KnowledgeBaseQueryGenerationTableOutput +} + +// Tables used for Redshift query generation context +type KnowledgeBaseQueryGenerationTableArgs struct { + Columns KnowledgeBaseQueryGenerationColumnArrayInput `pulumi:"columns"` + Description pulumi.StringPtrInput `pulumi:"description"` + Inclusion KnowledgeBaseInclusionTypePtrInput `pulumi:"inclusion"` + Name pulumi.StringInput `pulumi:"name"` +} + +func (KnowledgeBaseQueryGenerationTableArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryGenerationTable)(nil)).Elem() +} + +func (i KnowledgeBaseQueryGenerationTableArgs) ToKnowledgeBaseQueryGenerationTableOutput() KnowledgeBaseQueryGenerationTableOutput { + return i.ToKnowledgeBaseQueryGenerationTableOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseQueryGenerationTableArgs) ToKnowledgeBaseQueryGenerationTableOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationTableOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationTableOutput) +} + +// KnowledgeBaseQueryGenerationTableArrayInput is an input type that accepts KnowledgeBaseQueryGenerationTableArray and KnowledgeBaseQueryGenerationTableArrayOutput values. +// You can construct a concrete instance of `KnowledgeBaseQueryGenerationTableArrayInput` via: +// +// KnowledgeBaseQueryGenerationTableArray{ KnowledgeBaseQueryGenerationTableArgs{...} } +type KnowledgeBaseQueryGenerationTableArrayInput interface { + pulumi.Input + + ToKnowledgeBaseQueryGenerationTableArrayOutput() KnowledgeBaseQueryGenerationTableArrayOutput + ToKnowledgeBaseQueryGenerationTableArrayOutputWithContext(context.Context) KnowledgeBaseQueryGenerationTableArrayOutput +} + +type KnowledgeBaseQueryGenerationTableArray []KnowledgeBaseQueryGenerationTableInput + +func (KnowledgeBaseQueryGenerationTableArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]KnowledgeBaseQueryGenerationTable)(nil)).Elem() +} + +func (i KnowledgeBaseQueryGenerationTableArray) ToKnowledgeBaseQueryGenerationTableArrayOutput() KnowledgeBaseQueryGenerationTableArrayOutput { + return i.ToKnowledgeBaseQueryGenerationTableArrayOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseQueryGenerationTableArray) ToKnowledgeBaseQueryGenerationTableArrayOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationTableArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseQueryGenerationTableArrayOutput) +} + +// Tables used for Redshift query generation context +type KnowledgeBaseQueryGenerationTableOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseQueryGenerationTableOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseQueryGenerationTable)(nil)).Elem() +} + +func (o KnowledgeBaseQueryGenerationTableOutput) ToKnowledgeBaseQueryGenerationTableOutput() KnowledgeBaseQueryGenerationTableOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationTableOutput) ToKnowledgeBaseQueryGenerationTableOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationTableOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationTableOutput) Columns() KnowledgeBaseQueryGenerationColumnArrayOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationTable) []KnowledgeBaseQueryGenerationColumn { return v.Columns }).(KnowledgeBaseQueryGenerationColumnArrayOutput) +} + +func (o KnowledgeBaseQueryGenerationTableOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationTable) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o KnowledgeBaseQueryGenerationTableOutput) Inclusion() KnowledgeBaseInclusionTypePtrOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationTable) *KnowledgeBaseInclusionType { return v.Inclusion }).(KnowledgeBaseInclusionTypePtrOutput) +} + +func (o KnowledgeBaseQueryGenerationTableOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseQueryGenerationTable) string { return v.Name }).(pulumi.StringOutput) +} + +type KnowledgeBaseQueryGenerationTableArrayOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseQueryGenerationTableArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]KnowledgeBaseQueryGenerationTable)(nil)).Elem() +} + +func (o KnowledgeBaseQueryGenerationTableArrayOutput) ToKnowledgeBaseQueryGenerationTableArrayOutput() KnowledgeBaseQueryGenerationTableArrayOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationTableArrayOutput) ToKnowledgeBaseQueryGenerationTableArrayOutputWithContext(ctx context.Context) KnowledgeBaseQueryGenerationTableArrayOutput { + return o +} + +func (o KnowledgeBaseQueryGenerationTableArrayOutput) Index(i pulumi.IntInput) KnowledgeBaseQueryGenerationTableOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) KnowledgeBaseQueryGenerationTable { + return vs[0].([]KnowledgeBaseQueryGenerationTable)[vs[1].(int)] + }).(KnowledgeBaseQueryGenerationTableOutput) +} + +// Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS. +type KnowledgeBaseRdsConfiguration struct { + // The ARN of the secret that you created in AWS Secrets Manager that is linked to your Amazon RDS database. + CredentialsSecretArn string `pulumi:"credentialsSecretArn"` + // The name of your Amazon RDS database. + DatabaseName string `pulumi:"databaseName"` + // Contains the names of the fields to which to map information about the vector store. + FieldMapping KnowledgeBaseRdsFieldMapping `pulumi:"fieldMapping"` + // The ARN of the vector store. + ResourceArn string `pulumi:"resourceArn"` + // The name of the table in the database. + TableName string `pulumi:"tableName"` +} + +// KnowledgeBaseRdsConfigurationInput is an input type that accepts KnowledgeBaseRdsConfigurationArgs and KnowledgeBaseRdsConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRdsConfigurationInput` via: +// +// KnowledgeBaseRdsConfigurationArgs{...} +type KnowledgeBaseRdsConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRdsConfigurationOutput() KnowledgeBaseRdsConfigurationOutput + ToKnowledgeBaseRdsConfigurationOutputWithContext(context.Context) KnowledgeBaseRdsConfigurationOutput +} + +// Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS. +type KnowledgeBaseRdsConfigurationArgs struct { + // The ARN of the secret that you created in AWS Secrets Manager that is linked to your Amazon RDS database. + CredentialsSecretArn pulumi.StringInput `pulumi:"credentialsSecretArn"` + // The name of your Amazon RDS database. + DatabaseName pulumi.StringInput `pulumi:"databaseName"` + // Contains the names of the fields to which to map information about the vector store. + FieldMapping KnowledgeBaseRdsFieldMappingInput `pulumi:"fieldMapping"` + // The ARN of the vector store. + ResourceArn pulumi.StringInput `pulumi:"resourceArn"` + // The name of the table in the database. + TableName pulumi.StringInput `pulumi:"tableName"` +} + +func (KnowledgeBaseRdsConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRdsConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRdsConfigurationArgs) ToKnowledgeBaseRdsConfigurationOutput() KnowledgeBaseRdsConfigurationOutput { + return i.ToKnowledgeBaseRdsConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRdsConfigurationArgs) ToKnowledgeBaseRdsConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsConfigurationOutput) +} + +func (i KnowledgeBaseRdsConfigurationArgs) ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput { + return i.ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRdsConfigurationArgs) ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsConfigurationOutput).ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRdsConfigurationPtrInput is an input type that accepts KnowledgeBaseRdsConfigurationArgs, KnowledgeBaseRdsConfigurationPtr and KnowledgeBaseRdsConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRdsConfigurationPtrInput` via: +// +// KnowledgeBaseRdsConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRdsConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput + ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRdsConfigurationPtrOutput +} + +type knowledgeBaseRdsConfigurationPtrType KnowledgeBaseRdsConfigurationArgs + +func KnowledgeBaseRdsConfigurationPtr(v *KnowledgeBaseRdsConfigurationArgs) KnowledgeBaseRdsConfigurationPtrInput { + return (*knowledgeBaseRdsConfigurationPtrType)(v) +} + +func (*knowledgeBaseRdsConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRdsConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseRdsConfigurationPtrType) ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput { + return i.ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRdsConfigurationPtrType) ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsConfigurationPtrOutput) +} + +// Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS. +type KnowledgeBaseRdsConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRdsConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRdsConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRdsConfigurationOutput) ToKnowledgeBaseRdsConfigurationOutput() KnowledgeBaseRdsConfigurationOutput { + return o +} + +func (o KnowledgeBaseRdsConfigurationOutput) ToKnowledgeBaseRdsConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationOutput { + return o +} + +func (o KnowledgeBaseRdsConfigurationOutput) ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput { + return o.ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRdsConfigurationOutput) ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRdsConfiguration) *KnowledgeBaseRdsConfiguration { + return &v + }).(KnowledgeBaseRdsConfigurationPtrOutput) +} + +// The ARN of the secret that you created in AWS Secrets Manager that is linked to your Amazon RDS database. +func (o KnowledgeBaseRdsConfigurationOutput) CredentialsSecretArn() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) string { return v.CredentialsSecretArn }).(pulumi.StringOutput) +} + +// The name of your Amazon RDS database. +func (o KnowledgeBaseRdsConfigurationOutput) DatabaseName() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) string { return v.DatabaseName }).(pulumi.StringOutput) +} + +// Contains the names of the fields to which to map information about the vector store. +func (o KnowledgeBaseRdsConfigurationOutput) FieldMapping() KnowledgeBaseRdsFieldMappingOutput { + return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) KnowledgeBaseRdsFieldMapping { return v.FieldMapping }).(KnowledgeBaseRdsFieldMappingOutput) +} + +// The ARN of the vector store. +func (o KnowledgeBaseRdsConfigurationOutput) ResourceArn() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) string { return v.ResourceArn }).(pulumi.StringOutput) +} + +// The name of the table in the database. +func (o KnowledgeBaseRdsConfigurationOutput) TableName() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRdsConfiguration) string { return v.TableName }).(pulumi.StringOutput) +} + +type KnowledgeBaseRdsConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRdsConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRdsConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRdsConfigurationPtrOutput) ToKnowledgeBaseRdsConfigurationPtrOutput() KnowledgeBaseRdsConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRdsConfigurationPtrOutput) ToKnowledgeBaseRdsConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRdsConfigurationPtrOutput) Elem() KnowledgeBaseRdsConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) KnowledgeBaseRdsConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseRdsConfiguration + return ret + }).(KnowledgeBaseRdsConfigurationOutput) +} + +// The ARN of the secret that you created in AWS Secrets Manager that is linked to your Amazon RDS database. +func (o KnowledgeBaseRdsConfigurationPtrOutput) CredentialsSecretArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *string { + if v == nil { + return nil + } + return &v.CredentialsSecretArn + }).(pulumi.StringPtrOutput) +} + +// The name of your Amazon RDS database. +func (o KnowledgeBaseRdsConfigurationPtrOutput) DatabaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *string { + if v == nil { + return nil + } + return &v.DatabaseName + }).(pulumi.StringPtrOutput) +} + +// Contains the names of the fields to which to map information about the vector store. +func (o KnowledgeBaseRdsConfigurationPtrOutput) FieldMapping() KnowledgeBaseRdsFieldMappingPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *KnowledgeBaseRdsFieldMapping { + if v == nil { + return nil + } + return &v.FieldMapping + }).(KnowledgeBaseRdsFieldMappingPtrOutput) +} + +// The ARN of the vector store. +func (o KnowledgeBaseRdsConfigurationPtrOutput) ResourceArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *string { + if v == nil { + return nil + } + return &v.ResourceArn + }).(pulumi.StringPtrOutput) +} + +// The name of the table in the database. +func (o KnowledgeBaseRdsConfigurationPtrOutput) TableName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *string { + if v == nil { + return nil + } + return &v.TableName + }).(pulumi.StringPtrOutput) } // Contains the names of the fields to which to map information about the vector store. -func (o KnowledgeBaseRdsConfigurationPtrOutput) FieldMapping() KnowledgeBaseRdsFieldMappingPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *KnowledgeBaseRdsFieldMapping { +type KnowledgeBaseRdsFieldMapping struct { + // The name of the field in which Amazon Bedrock stores metadata about the vector store. + MetadataField string `pulumi:"metadataField"` + // The name of the field in which Amazon Bedrock stores the ID for each entry. + PrimaryKeyField string `pulumi:"primaryKeyField"` + // The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose. + TextField string `pulumi:"textField"` + // The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources. + VectorField string `pulumi:"vectorField"` +} + +// KnowledgeBaseRdsFieldMappingInput is an input type that accepts KnowledgeBaseRdsFieldMappingArgs and KnowledgeBaseRdsFieldMappingOutput values. +// You can construct a concrete instance of `KnowledgeBaseRdsFieldMappingInput` via: +// +// KnowledgeBaseRdsFieldMappingArgs{...} +type KnowledgeBaseRdsFieldMappingInput interface { + pulumi.Input + + ToKnowledgeBaseRdsFieldMappingOutput() KnowledgeBaseRdsFieldMappingOutput + ToKnowledgeBaseRdsFieldMappingOutputWithContext(context.Context) KnowledgeBaseRdsFieldMappingOutput +} + +// Contains the names of the fields to which to map information about the vector store. +type KnowledgeBaseRdsFieldMappingArgs struct { + // The name of the field in which Amazon Bedrock stores metadata about the vector store. + MetadataField pulumi.StringInput `pulumi:"metadataField"` + // The name of the field in which Amazon Bedrock stores the ID for each entry. + PrimaryKeyField pulumi.StringInput `pulumi:"primaryKeyField"` + // The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose. + TextField pulumi.StringInput `pulumi:"textField"` + // The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources. + VectorField pulumi.StringInput `pulumi:"vectorField"` +} + +func (KnowledgeBaseRdsFieldMappingArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRdsFieldMapping)(nil)).Elem() +} + +func (i KnowledgeBaseRdsFieldMappingArgs) ToKnowledgeBaseRdsFieldMappingOutput() KnowledgeBaseRdsFieldMappingOutput { + return i.ToKnowledgeBaseRdsFieldMappingOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRdsFieldMappingArgs) ToKnowledgeBaseRdsFieldMappingOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsFieldMappingOutput) +} + +func (i KnowledgeBaseRdsFieldMappingArgs) ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput { + return i.ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRdsFieldMappingArgs) ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsFieldMappingOutput).ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRdsFieldMappingPtrInput is an input type that accepts KnowledgeBaseRdsFieldMappingArgs, KnowledgeBaseRdsFieldMappingPtr and KnowledgeBaseRdsFieldMappingPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRdsFieldMappingPtrInput` via: +// +// KnowledgeBaseRdsFieldMappingArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRdsFieldMappingPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput + ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(context.Context) KnowledgeBaseRdsFieldMappingPtrOutput +} + +type knowledgeBaseRdsFieldMappingPtrType KnowledgeBaseRdsFieldMappingArgs + +func KnowledgeBaseRdsFieldMappingPtr(v *KnowledgeBaseRdsFieldMappingArgs) KnowledgeBaseRdsFieldMappingPtrInput { + return (*knowledgeBaseRdsFieldMappingPtrType)(v) +} + +func (*knowledgeBaseRdsFieldMappingPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRdsFieldMapping)(nil)).Elem() +} + +func (i *knowledgeBaseRdsFieldMappingPtrType) ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput { + return i.ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRdsFieldMappingPtrType) ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsFieldMappingPtrOutput) +} + +// Contains the names of the fields to which to map information about the vector store. +type KnowledgeBaseRdsFieldMappingOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRdsFieldMappingOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRdsFieldMapping)(nil)).Elem() +} + +func (o KnowledgeBaseRdsFieldMappingOutput) ToKnowledgeBaseRdsFieldMappingOutput() KnowledgeBaseRdsFieldMappingOutput { + return o +} + +func (o KnowledgeBaseRdsFieldMappingOutput) ToKnowledgeBaseRdsFieldMappingOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingOutput { + return o +} + +func (o KnowledgeBaseRdsFieldMappingOutput) ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput { + return o.ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRdsFieldMappingOutput) ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRdsFieldMapping) *KnowledgeBaseRdsFieldMapping { + return &v + }).(KnowledgeBaseRdsFieldMappingPtrOutput) +} + +// The name of the field in which Amazon Bedrock stores metadata about the vector store. +func (o KnowledgeBaseRdsFieldMappingOutput) MetadataField() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRdsFieldMapping) string { return v.MetadataField }).(pulumi.StringOutput) +} + +// The name of the field in which Amazon Bedrock stores the ID for each entry. +func (o KnowledgeBaseRdsFieldMappingOutput) PrimaryKeyField() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRdsFieldMapping) string { return v.PrimaryKeyField }).(pulumi.StringOutput) +} + +// The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose. +func (o KnowledgeBaseRdsFieldMappingOutput) TextField() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRdsFieldMapping) string { return v.TextField }).(pulumi.StringOutput) +} + +// The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources. +func (o KnowledgeBaseRdsFieldMappingOutput) VectorField() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRdsFieldMapping) string { return v.VectorField }).(pulumi.StringOutput) +} + +type KnowledgeBaseRdsFieldMappingPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRdsFieldMappingPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRdsFieldMapping)(nil)).Elem() +} + +func (o KnowledgeBaseRdsFieldMappingPtrOutput) ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput { + return o +} + +func (o KnowledgeBaseRdsFieldMappingPtrOutput) ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingPtrOutput { + return o +} + +func (o KnowledgeBaseRdsFieldMappingPtrOutput) Elem() KnowledgeBaseRdsFieldMappingOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) KnowledgeBaseRdsFieldMapping { + if v != nil { + return *v + } + var ret KnowledgeBaseRdsFieldMapping + return ret + }).(KnowledgeBaseRdsFieldMappingOutput) +} + +// The name of the field in which Amazon Bedrock stores metadata about the vector store. +func (o KnowledgeBaseRdsFieldMappingPtrOutput) MetadataField() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) *string { + if v == nil { + return nil + } + return &v.MetadataField + }).(pulumi.StringPtrOutput) +} + +// The name of the field in which Amazon Bedrock stores the ID for each entry. +func (o KnowledgeBaseRdsFieldMappingPtrOutput) PrimaryKeyField() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) *string { + if v == nil { + return nil + } + return &v.PrimaryKeyField + }).(pulumi.StringPtrOutput) +} + +// The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose. +func (o KnowledgeBaseRdsFieldMappingPtrOutput) TextField() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) *string { + if v == nil { + return nil + } + return &v.TextField + }).(pulumi.StringPtrOutput) +} + +// The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources. +func (o KnowledgeBaseRdsFieldMappingPtrOutput) VectorField() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) *string { + if v == nil { + return nil + } + return &v.VectorField + }).(pulumi.StringPtrOutput) +} + +// Configurations for a Redshift knowledge base +type KnowledgeBaseRedshiftConfiguration struct { + QueryEngineConfiguration KnowledgeBaseRedshiftQueryEngineConfiguration `pulumi:"queryEngineConfiguration"` + QueryGenerationConfiguration *KnowledgeBaseQueryGenerationConfiguration `pulumi:"queryGenerationConfiguration"` + StorageConfigurations []KnowledgeBaseRedshiftQueryEngineStorageConfiguration `pulumi:"storageConfigurations"` +} + +// KnowledgeBaseRedshiftConfigurationInput is an input type that accepts KnowledgeBaseRedshiftConfigurationArgs and KnowledgeBaseRedshiftConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftConfigurationInput` via: +// +// KnowledgeBaseRedshiftConfigurationArgs{...} +type KnowledgeBaseRedshiftConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftConfigurationOutput() KnowledgeBaseRedshiftConfigurationOutput + ToKnowledgeBaseRedshiftConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftConfigurationOutput +} + +// Configurations for a Redshift knowledge base +type KnowledgeBaseRedshiftConfigurationArgs struct { + QueryEngineConfiguration KnowledgeBaseRedshiftQueryEngineConfigurationInput `pulumi:"queryEngineConfiguration"` + QueryGenerationConfiguration KnowledgeBaseQueryGenerationConfigurationPtrInput `pulumi:"queryGenerationConfiguration"` + StorageConfigurations KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayInput `pulumi:"storageConfigurations"` +} + +func (KnowledgeBaseRedshiftConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftConfigurationArgs) ToKnowledgeBaseRedshiftConfigurationOutput() KnowledgeBaseRedshiftConfigurationOutput { + return i.ToKnowledgeBaseRedshiftConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftConfigurationArgs) ToKnowledgeBaseRedshiftConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftConfigurationOutput) +} + +func (i KnowledgeBaseRedshiftConfigurationArgs) ToKnowledgeBaseRedshiftConfigurationPtrOutput() KnowledgeBaseRedshiftConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftConfigurationArgs) ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftConfigurationOutput).ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRedshiftConfigurationPtrInput is an input type that accepts KnowledgeBaseRedshiftConfigurationArgs, KnowledgeBaseRedshiftConfigurationPtr and KnowledgeBaseRedshiftConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftConfigurationPtrInput` via: +// +// KnowledgeBaseRedshiftConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRedshiftConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftConfigurationPtrOutput() KnowledgeBaseRedshiftConfigurationPtrOutput + ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRedshiftConfigurationPtrOutput +} + +type knowledgeBaseRedshiftConfigurationPtrType KnowledgeBaseRedshiftConfigurationArgs + +func KnowledgeBaseRedshiftConfigurationPtr(v *KnowledgeBaseRedshiftConfigurationArgs) KnowledgeBaseRedshiftConfigurationPtrInput { + return (*knowledgeBaseRedshiftConfigurationPtrType)(v) +} + +func (*knowledgeBaseRedshiftConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseRedshiftConfigurationPtrType) ToKnowledgeBaseRedshiftConfigurationPtrOutput() KnowledgeBaseRedshiftConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRedshiftConfigurationPtrType) ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftConfigurationPtrOutput) +} + +// Configurations for a Redshift knowledge base +type KnowledgeBaseRedshiftConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftConfigurationOutput) ToKnowledgeBaseRedshiftConfigurationOutput() KnowledgeBaseRedshiftConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftConfigurationOutput) ToKnowledgeBaseRedshiftConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftConfigurationOutput) ToKnowledgeBaseRedshiftConfigurationPtrOutput() KnowledgeBaseRedshiftConfigurationPtrOutput { + return o.ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftConfigurationOutput) ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftConfiguration) *KnowledgeBaseRedshiftConfiguration { + return &v + }).(KnowledgeBaseRedshiftConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftConfigurationOutput) QueryEngineConfiguration() KnowledgeBaseRedshiftQueryEngineConfigurationOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftConfiguration) KnowledgeBaseRedshiftQueryEngineConfiguration { + return v.QueryEngineConfiguration + }).(KnowledgeBaseRedshiftQueryEngineConfigurationOutput) +} + +func (o KnowledgeBaseRedshiftConfigurationOutput) QueryGenerationConfiguration() KnowledgeBaseQueryGenerationConfigurationPtrOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftConfiguration) *KnowledgeBaseQueryGenerationConfiguration { + return v.QueryGenerationConfiguration + }).(KnowledgeBaseQueryGenerationConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftConfigurationOutput) StorageConfigurations() KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftConfiguration) []KnowledgeBaseRedshiftQueryEngineStorageConfiguration { + return v.StorageConfigurations + }).(KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput) +} + +type KnowledgeBaseRedshiftConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftConfigurationPtrOutput) ToKnowledgeBaseRedshiftConfigurationPtrOutput() KnowledgeBaseRedshiftConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftConfigurationPtrOutput) ToKnowledgeBaseRedshiftConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftConfigurationPtrOutput) Elem() KnowledgeBaseRedshiftConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftConfiguration) KnowledgeBaseRedshiftConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftConfiguration + return ret + }).(KnowledgeBaseRedshiftConfigurationOutput) +} + +func (o KnowledgeBaseRedshiftConfigurationPtrOutput) QueryEngineConfiguration() KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftConfiguration) *KnowledgeBaseRedshiftQueryEngineConfiguration { + if v == nil { + return nil + } + return &v.QueryEngineConfiguration + }).(KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftConfigurationPtrOutput) QueryGenerationConfiguration() KnowledgeBaseQueryGenerationConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftConfiguration) *KnowledgeBaseQueryGenerationConfiguration { + if v == nil { + return nil + } + return v.QueryGenerationConfiguration + }).(KnowledgeBaseQueryGenerationConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftConfigurationPtrOutput) StorageConfigurations() KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftConfiguration) []KnowledgeBaseRedshiftQueryEngineStorageConfiguration { + if v == nil { + return nil + } + return v.StorageConfigurations + }).(KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput) +} + +// Configurations for Redshift query engine provisioned auth setup +type KnowledgeBaseRedshiftProvisionedAuthConfiguration struct { + // Redshift database user + DatabaseUser *string `pulumi:"databaseUser"` + Type KnowledgeBaseRedshiftProvisionedAuthType `pulumi:"type"` + UsernamePasswordSecretArn *string `pulumi:"usernamePasswordSecretArn"` +} + +// KnowledgeBaseRedshiftProvisionedAuthConfigurationInput is an input type that accepts KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs and KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftProvisionedAuthConfigurationInput` via: +// +// KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs{...} +type KnowledgeBaseRedshiftProvisionedAuthConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftProvisionedAuthConfigurationOutput() KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput + ToKnowledgeBaseRedshiftProvisionedAuthConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput +} + +// Configurations for Redshift query engine provisioned auth setup +type KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs struct { + // Redshift database user + DatabaseUser pulumi.StringPtrInput `pulumi:"databaseUser"` + Type KnowledgeBaseRedshiftProvisionedAuthTypeInput `pulumi:"type"` + UsernamePasswordSecretArn pulumi.StringPtrInput `pulumi:"usernamePasswordSecretArn"` +} + +func (KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedAuthConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationOutput() KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput { + return i.ToKnowledgeBaseRedshiftProvisionedAuthConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) +} + +func (i KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput).ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrInput is an input type that accepts KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs, KnowledgeBaseRedshiftProvisionedAuthConfigurationPtr and KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrInput` via: +// +// KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput + ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput +} + +type knowledgeBaseRedshiftProvisionedAuthConfigurationPtrType KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs + +func KnowledgeBaseRedshiftProvisionedAuthConfigurationPtr(v *KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs) KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrInput { + return (*knowledgeBaseRedshiftProvisionedAuthConfigurationPtrType)(v) +} + +func (*knowledgeBaseRedshiftProvisionedAuthConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftProvisionedAuthConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseRedshiftProvisionedAuthConfigurationPtrType) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRedshiftProvisionedAuthConfigurationPtrType) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) +} + +// Configurations for Redshift query engine provisioned auth setup +type KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedAuthConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationOutput() KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return o.ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftProvisionedAuthConfiguration) *KnowledgeBaseRedshiftProvisionedAuthConfiguration { + return &v + }).(KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) +} + +// Redshift database user +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) DatabaseUser() pulumi.StringPtrOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftProvisionedAuthConfiguration) *string { return v.DatabaseUser }).(pulumi.StringPtrOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) Type() KnowledgeBaseRedshiftProvisionedAuthTypeOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftProvisionedAuthConfiguration) KnowledgeBaseRedshiftProvisionedAuthType { + return v.Type + }).(KnowledgeBaseRedshiftProvisionedAuthTypeOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) UsernamePasswordSecretArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftProvisionedAuthConfiguration) *string { return v.UsernamePasswordSecretArn }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftProvisionedAuthConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) ToKnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) Elem() KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftProvisionedAuthConfiguration) KnowledgeBaseRedshiftProvisionedAuthConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftProvisionedAuthConfiguration + return ret + }).(KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) +} + +// Redshift database user +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) DatabaseUser() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftProvisionedAuthConfiguration) *string { + if v == nil { + return nil + } + return v.DatabaseUser + }).(pulumi.StringPtrOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) Type() KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftProvisionedAuthConfiguration) *KnowledgeBaseRedshiftProvisionedAuthType { + if v == nil { + return nil + } + return &v.Type + }).(KnowledgeBaseRedshiftProvisionedAuthTypePtrOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) UsernamePasswordSecretArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftProvisionedAuthConfiguration) *string { + if v == nil { + return nil + } + return v.UsernamePasswordSecretArn + }).(pulumi.StringPtrOutput) +} + +// Configurations for provisioned Redshift query engine +type KnowledgeBaseRedshiftProvisionedConfiguration struct { + AuthConfiguration KnowledgeBaseRedshiftProvisionedAuthConfiguration `pulumi:"authConfiguration"` + ClusterIdentifier string `pulumi:"clusterIdentifier"` +} + +// KnowledgeBaseRedshiftProvisionedConfigurationInput is an input type that accepts KnowledgeBaseRedshiftProvisionedConfigurationArgs and KnowledgeBaseRedshiftProvisionedConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftProvisionedConfigurationInput` via: +// +// KnowledgeBaseRedshiftProvisionedConfigurationArgs{...} +type KnowledgeBaseRedshiftProvisionedConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftProvisionedConfigurationOutput() KnowledgeBaseRedshiftProvisionedConfigurationOutput + ToKnowledgeBaseRedshiftProvisionedConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftProvisionedConfigurationOutput +} + +// Configurations for provisioned Redshift query engine +type KnowledgeBaseRedshiftProvisionedConfigurationArgs struct { + AuthConfiguration KnowledgeBaseRedshiftProvisionedAuthConfigurationInput `pulumi:"authConfiguration"` + ClusterIdentifier pulumi.StringInput `pulumi:"clusterIdentifier"` +} + +func (KnowledgeBaseRedshiftProvisionedConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftProvisionedConfigurationArgs) ToKnowledgeBaseRedshiftProvisionedConfigurationOutput() KnowledgeBaseRedshiftProvisionedConfigurationOutput { + return i.ToKnowledgeBaseRedshiftProvisionedConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftProvisionedConfigurationArgs) ToKnowledgeBaseRedshiftProvisionedConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftProvisionedConfigurationOutput) +} + +func (i KnowledgeBaseRedshiftProvisionedConfigurationArgs) ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftProvisionedConfigurationArgs) ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftProvisionedConfigurationOutput).ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRedshiftProvisionedConfigurationPtrInput is an input type that accepts KnowledgeBaseRedshiftProvisionedConfigurationArgs, KnowledgeBaseRedshiftProvisionedConfigurationPtr and KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftProvisionedConfigurationPtrInput` via: +// +// KnowledgeBaseRedshiftProvisionedConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRedshiftProvisionedConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput + ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput +} + +type knowledgeBaseRedshiftProvisionedConfigurationPtrType KnowledgeBaseRedshiftProvisionedConfigurationArgs + +func KnowledgeBaseRedshiftProvisionedConfigurationPtr(v *KnowledgeBaseRedshiftProvisionedConfigurationArgs) KnowledgeBaseRedshiftProvisionedConfigurationPtrInput { + return (*knowledgeBaseRedshiftProvisionedConfigurationPtrType)(v) +} + +func (*knowledgeBaseRedshiftProvisionedConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftProvisionedConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseRedshiftProvisionedConfigurationPtrType) ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRedshiftProvisionedConfigurationPtrType) ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) +} + +// Configurations for provisioned Redshift query engine +type KnowledgeBaseRedshiftProvisionedConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftProvisionedConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationOutput) ToKnowledgeBaseRedshiftProvisionedConfigurationOutput() KnowledgeBaseRedshiftProvisionedConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationOutput) ToKnowledgeBaseRedshiftProvisionedConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationOutput) ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return o.ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationOutput) ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftProvisionedConfiguration) *KnowledgeBaseRedshiftProvisionedConfiguration { + return &v + }).(KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationOutput) AuthConfiguration() KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftProvisionedConfiguration) KnowledgeBaseRedshiftProvisionedAuthConfiguration { + return v.AuthConfiguration + }).(KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationOutput) ClusterIdentifier() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftProvisionedConfiguration) string { return v.ClusterIdentifier }).(pulumi.StringOutput) +} + +type KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftProvisionedConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutput() KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) ToKnowledgeBaseRedshiftProvisionedConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) Elem() KnowledgeBaseRedshiftProvisionedConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftProvisionedConfiguration) KnowledgeBaseRedshiftProvisionedConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftProvisionedConfiguration + return ret + }).(KnowledgeBaseRedshiftProvisionedConfigurationOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) AuthConfiguration() KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftProvisionedConfiguration) *KnowledgeBaseRedshiftProvisionedAuthConfiguration { + if v == nil { + return nil + } + return &v.AuthConfiguration + }).(KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) ClusterIdentifier() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftProvisionedConfiguration) *string { + if v == nil { + return nil + } + return &v.ClusterIdentifier + }).(pulumi.StringPtrOutput) +} + +// Configurations for Redshift query engine AWS Data Catalog backed storage +type KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration struct { + TableNames []string `pulumi:"tableNames"` +} + +// KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationInput is an input type that accepts KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs and KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationInput` via: +// +// KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs{...} +type KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput + ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput +} + +// Configurations for Redshift query engine AWS Data Catalog backed storage +type KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs struct { + TableNames pulumi.StringArrayInput `pulumi:"tableNames"` +} + +func (KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput) +} + +func (i KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput).ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrInput is an input type that accepts KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs, KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtr and KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrInput` via: +// +// KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput + ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput +} + +type knowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrType KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs + +func KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtr(v *KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrInput { + return (*knowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrType)(v) +} + +func (*knowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrType) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrType) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput) +} + +// Configurations for Redshift query engine AWS Data Catalog backed storage +type KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return o.ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration) *KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration { + return &v + }).(KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput) TableNames() pulumi.StringArrayOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration) []string { + return v.TableNames + }).(pulumi.StringArrayOutput) +} + +type KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput) ToKnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput) Elem() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration) KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration + return ret + }).(KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput) TableNames() pulumi.StringArrayOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration) []string { + if v == nil { + return nil + } + return v.TableNames + }).(pulumi.StringArrayOutput) +} + +// Configurations for Redshift query engine +type KnowledgeBaseRedshiftQueryEngineConfiguration struct { + ProvisionedConfiguration *KnowledgeBaseRedshiftProvisionedConfiguration `pulumi:"provisionedConfiguration"` + ServerlessConfiguration *KnowledgeBaseRedshiftServerlessConfiguration `pulumi:"serverlessConfiguration"` + Type KnowledgeBaseRedshiftQueryEngineType `pulumi:"type"` +} + +// KnowledgeBaseRedshiftQueryEngineConfigurationInput is an input type that accepts KnowledgeBaseRedshiftQueryEngineConfigurationArgs and KnowledgeBaseRedshiftQueryEngineConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftQueryEngineConfigurationInput` via: +// +// KnowledgeBaseRedshiftQueryEngineConfigurationArgs{...} +type KnowledgeBaseRedshiftQueryEngineConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineConfigurationOutput() KnowledgeBaseRedshiftQueryEngineConfigurationOutput + ToKnowledgeBaseRedshiftQueryEngineConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineConfigurationOutput +} + +// Configurations for Redshift query engine +type KnowledgeBaseRedshiftQueryEngineConfigurationArgs struct { + ProvisionedConfiguration KnowledgeBaseRedshiftProvisionedConfigurationPtrInput `pulumi:"provisionedConfiguration"` + ServerlessConfiguration KnowledgeBaseRedshiftServerlessConfigurationPtrInput `pulumi:"serverlessConfiguration"` + Type KnowledgeBaseRedshiftQueryEngineTypeInput `pulumi:"type"` +} + +func (KnowledgeBaseRedshiftQueryEngineConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftQueryEngineConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineConfigurationOutput() KnowledgeBaseRedshiftQueryEngineConfigurationOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftQueryEngineConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineConfigurationOutput) +} + +func (i KnowledgeBaseRedshiftQueryEngineConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftQueryEngineConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineConfigurationOutput).ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRedshiftQueryEngineConfigurationPtrInput is an input type that accepts KnowledgeBaseRedshiftQueryEngineConfigurationArgs, KnowledgeBaseRedshiftQueryEngineConfigurationPtr and KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftQueryEngineConfigurationPtrInput` via: +// +// KnowledgeBaseRedshiftQueryEngineConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRedshiftQueryEngineConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput + ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput +} + +type knowledgeBaseRedshiftQueryEngineConfigurationPtrType KnowledgeBaseRedshiftQueryEngineConfigurationArgs + +func KnowledgeBaseRedshiftQueryEngineConfigurationPtr(v *KnowledgeBaseRedshiftQueryEngineConfigurationArgs) KnowledgeBaseRedshiftQueryEngineConfigurationPtrInput { + return (*knowledgeBaseRedshiftQueryEngineConfigurationPtrType)(v) +} + +func (*knowledgeBaseRedshiftQueryEngineConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseRedshiftQueryEngineConfigurationPtrType) ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRedshiftQueryEngineConfigurationPtrType) ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) +} + +// Configurations for Redshift query engine +type KnowledgeBaseRedshiftQueryEngineConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineConfigurationOutput() KnowledgeBaseRedshiftQueryEngineConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return o.ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftQueryEngineConfiguration) *KnowledgeBaseRedshiftQueryEngineConfiguration { + return &v + }).(KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationOutput) ProvisionedConfiguration() KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftQueryEngineConfiguration) *KnowledgeBaseRedshiftProvisionedConfiguration { + return v.ProvisionedConfiguration + }).(KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationOutput) ServerlessConfiguration() KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftQueryEngineConfiguration) *KnowledgeBaseRedshiftServerlessConfiguration { + return v.ServerlessConfiguration + }).(KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationOutput) Type() KnowledgeBaseRedshiftQueryEngineTypeOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftQueryEngineConfiguration) KnowledgeBaseRedshiftQueryEngineType { + return v.Type + }).(KnowledgeBaseRedshiftQueryEngineTypeOutput) +} + +type KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) ToKnowledgeBaseRedshiftQueryEngineConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) Elem() KnowledgeBaseRedshiftQueryEngineConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineConfiguration) KnowledgeBaseRedshiftQueryEngineConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftQueryEngineConfiguration + return ret + }).(KnowledgeBaseRedshiftQueryEngineConfigurationOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) ProvisionedConfiguration() KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineConfiguration) *KnowledgeBaseRedshiftProvisionedConfiguration { + if v == nil { + return nil + } + return v.ProvisionedConfiguration + }).(KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) ServerlessConfiguration() KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineConfiguration) *KnowledgeBaseRedshiftServerlessConfiguration { + if v == nil { + return nil + } + return v.ServerlessConfiguration + }).(KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput) Type() KnowledgeBaseRedshiftQueryEngineTypePtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineConfiguration) *KnowledgeBaseRedshiftQueryEngineType { + if v == nil { + return nil + } + return &v.Type + }).(KnowledgeBaseRedshiftQueryEngineTypePtrOutput) +} + +// Configurations for Redshift query engine Redshift backed storage +type KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration struct { + DatabaseName string `pulumi:"databaseName"` +} + +// KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationInput is an input type that accepts KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs and KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationInput` via: +// +// KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs{...} +type KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput + ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput +} + +// Configurations for Redshift query engine Redshift backed storage +type KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs struct { + DatabaseName pulumi.StringInput `pulumi:"databaseName"` +} + +func (KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput) +} + +func (i KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput).ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrInput is an input type that accepts KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs, KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtr and KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrInput` via: +// +// KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput + ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput +} + +type knowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrType KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs + +func KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtr(v *KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrInput { + return (*knowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrType)(v) +} + +func (*knowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrType) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrType) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput) +} + +// Configurations for Redshift query engine Redshift backed storage +type KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return o.ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration) *KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration { + return &v + }).(KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput) DatabaseName() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration) string { return v.DatabaseName }).(pulumi.StringOutput) +} + +type KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput) ToKnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput) Elem() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration) KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration + return ret + }).(KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput) DatabaseName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration) *string { if v == nil { return nil } - return &v.FieldMapping - }).(KnowledgeBaseRdsFieldMappingPtrOutput) + return &v.DatabaseName + }).(pulumi.StringPtrOutput) +} + +// Configurations for available Redshift query engine storage types +type KnowledgeBaseRedshiftQueryEngineStorageConfiguration struct { + AwsDataCatalogConfiguration *KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration `pulumi:"awsDataCatalogConfiguration"` + RedshiftConfiguration *KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration `pulumi:"redshiftConfiguration"` + Type KnowledgeBaseRedshiftQueryEngineStorageType `pulumi:"type"` +} + +// KnowledgeBaseRedshiftQueryEngineStorageConfigurationInput is an input type that accepts KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs and KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftQueryEngineStorageConfigurationInput` via: +// +// KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs{...} +type KnowledgeBaseRedshiftQueryEngineStorageConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput + ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput +} + +// Configurations for available Redshift query engine storage types +type KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs struct { + AwsDataCatalogConfiguration KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrInput `pulumi:"awsDataCatalogConfiguration"` + RedshiftConfiguration KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrInput `pulumi:"redshiftConfiguration"` + Type KnowledgeBaseRedshiftQueryEngineStorageTypeInput `pulumi:"type"` +} + +func (KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineStorageConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs) ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput) +} + +// KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayInput is an input type that accepts KnowledgeBaseRedshiftQueryEngineStorageConfigurationArray and KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayInput` via: +// +// KnowledgeBaseRedshiftQueryEngineStorageConfigurationArray{ KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs{...} } +type KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput() KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput + ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutputWithContext(context.Context) KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput +} + +type KnowledgeBaseRedshiftQueryEngineStorageConfigurationArray []KnowledgeBaseRedshiftQueryEngineStorageConfigurationInput + +func (KnowledgeBaseRedshiftQueryEngineStorageConfigurationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]KnowledgeBaseRedshiftQueryEngineStorageConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftQueryEngineStorageConfigurationArray) ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput() KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput { + return i.ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftQueryEngineStorageConfigurationArray) ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput) +} + +// Configurations for available Redshift query engine storage types +type KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineStorageConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput() KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput) ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput) AwsDataCatalogConfiguration() KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftQueryEngineStorageConfiguration) *KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration { + return v.AwsDataCatalogConfiguration + }).(KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput) RedshiftConfiguration() KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftQueryEngineStorageConfiguration) *KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration { + return v.RedshiftConfiguration + }).(KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput) Type() KnowledgeBaseRedshiftQueryEngineStorageTypeOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftQueryEngineStorageConfiguration) KnowledgeBaseRedshiftQueryEngineStorageType { + return v.Type + }).(KnowledgeBaseRedshiftQueryEngineStorageTypeOutput) +} + +type KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]KnowledgeBaseRedshiftQueryEngineStorageConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput) ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput() KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput) ToKnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput { + return o +} + +func (o KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput) Index(i pulumi.IntInput) KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) KnowledgeBaseRedshiftQueryEngineStorageConfiguration { + return vs[0].([]KnowledgeBaseRedshiftQueryEngineStorageConfiguration)[vs[1].(int)] + }).(KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput) +} + +// Configurations for Redshift query engine serverless auth setup +type KnowledgeBaseRedshiftServerlessAuthConfiguration struct { + Type KnowledgeBaseRedshiftServerlessAuthType `pulumi:"type"` + UsernamePasswordSecretArn *string `pulumi:"usernamePasswordSecretArn"` +} + +// KnowledgeBaseRedshiftServerlessAuthConfigurationInput is an input type that accepts KnowledgeBaseRedshiftServerlessAuthConfigurationArgs and KnowledgeBaseRedshiftServerlessAuthConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftServerlessAuthConfigurationInput` via: +// +// KnowledgeBaseRedshiftServerlessAuthConfigurationArgs{...} +type KnowledgeBaseRedshiftServerlessAuthConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftServerlessAuthConfigurationOutput() KnowledgeBaseRedshiftServerlessAuthConfigurationOutput + ToKnowledgeBaseRedshiftServerlessAuthConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftServerlessAuthConfigurationOutput +} + +// Configurations for Redshift query engine serverless auth setup +type KnowledgeBaseRedshiftServerlessAuthConfigurationArgs struct { + Type KnowledgeBaseRedshiftServerlessAuthTypeInput `pulumi:"type"` + UsernamePasswordSecretArn pulumi.StringPtrInput `pulumi:"usernamePasswordSecretArn"` +} + +func (KnowledgeBaseRedshiftServerlessAuthConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftServerlessAuthConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseRedshiftServerlessAuthConfigurationArgs) ToKnowledgeBaseRedshiftServerlessAuthConfigurationOutput() KnowledgeBaseRedshiftServerlessAuthConfigurationOutput { + return i.ToKnowledgeBaseRedshiftServerlessAuthConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftServerlessAuthConfigurationArgs) ToKnowledgeBaseRedshiftServerlessAuthConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) +} + +func (i KnowledgeBaseRedshiftServerlessAuthConfigurationArgs) ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseRedshiftServerlessAuthConfigurationArgs) ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftServerlessAuthConfigurationOutput).ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseRedshiftServerlessAuthConfigurationPtrInput is an input type that accepts KnowledgeBaseRedshiftServerlessAuthConfigurationArgs, KnowledgeBaseRedshiftServerlessAuthConfigurationPtr and KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftServerlessAuthConfigurationPtrInput` via: +// +// KnowledgeBaseRedshiftServerlessAuthConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseRedshiftServerlessAuthConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput + ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput +} + +type knowledgeBaseRedshiftServerlessAuthConfigurationPtrType KnowledgeBaseRedshiftServerlessAuthConfigurationArgs + +func KnowledgeBaseRedshiftServerlessAuthConfigurationPtr(v *KnowledgeBaseRedshiftServerlessAuthConfigurationArgs) KnowledgeBaseRedshiftServerlessAuthConfigurationPtrInput { + return (*knowledgeBaseRedshiftServerlessAuthConfigurationPtrType)(v) +} + +func (*knowledgeBaseRedshiftServerlessAuthConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftServerlessAuthConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseRedshiftServerlessAuthConfigurationPtrType) ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseRedshiftServerlessAuthConfigurationPtrType) ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) +} + +// Configurations for Redshift query engine serverless auth setup +type KnowledgeBaseRedshiftServerlessAuthConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftServerlessAuthConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) ToKnowledgeBaseRedshiftServerlessAuthConfigurationOutput() KnowledgeBaseRedshiftServerlessAuthConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) ToKnowledgeBaseRedshiftServerlessAuthConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthConfigurationOutput { + return o +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return o.ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftServerlessAuthConfiguration) *KnowledgeBaseRedshiftServerlessAuthConfiguration { + return &v + }).(KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) Type() KnowledgeBaseRedshiftServerlessAuthTypeOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftServerlessAuthConfiguration) KnowledgeBaseRedshiftServerlessAuthType { + return v.Type + }).(KnowledgeBaseRedshiftServerlessAuthTypeOutput) +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) UsernamePasswordSecretArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftServerlessAuthConfiguration) *string { return v.UsernamePasswordSecretArn }).(pulumi.StringPtrOutput) +} + +type KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftServerlessAuthConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) ToKnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) Elem() KnowledgeBaseRedshiftServerlessAuthConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftServerlessAuthConfiguration) KnowledgeBaseRedshiftServerlessAuthConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseRedshiftServerlessAuthConfiguration + return ret + }).(KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) } -// The ARN of the vector store. -func (o KnowledgeBaseRdsConfigurationPtrOutput) ResourceArn() pulumi.StringPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *string { +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) Type() KnowledgeBaseRedshiftServerlessAuthTypePtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftServerlessAuthConfiguration) *KnowledgeBaseRedshiftServerlessAuthType { if v == nil { return nil } - return &v.ResourceArn - }).(pulumi.StringPtrOutput) + return &v.Type + }).(KnowledgeBaseRedshiftServerlessAuthTypePtrOutput) } -// The name of the table in the database. -func (o KnowledgeBaseRdsConfigurationPtrOutput) TableName() pulumi.StringPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsConfiguration) *string { +func (o KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) UsernamePasswordSecretArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftServerlessAuthConfiguration) *string { if v == nil { return nil } - return &v.TableName + return v.UsernamePasswordSecretArn }).(pulumi.StringPtrOutput) } -// Contains the names of the fields to which to map information about the vector store. -type KnowledgeBaseRdsFieldMapping struct { - // The name of the field in which Amazon Bedrock stores metadata about the vector store. - MetadataField string `pulumi:"metadataField"` - // The name of the field in which Amazon Bedrock stores the ID for each entry. - PrimaryKeyField string `pulumi:"primaryKeyField"` - // The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose. - TextField string `pulumi:"textField"` - // The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources. - VectorField string `pulumi:"vectorField"` +// Configurations for serverless Redshift query engine +type KnowledgeBaseRedshiftServerlessConfiguration struct { + AuthConfiguration KnowledgeBaseRedshiftServerlessAuthConfiguration `pulumi:"authConfiguration"` + WorkgroupArn string `pulumi:"workgroupArn"` } -// KnowledgeBaseRdsFieldMappingInput is an input type that accepts KnowledgeBaseRdsFieldMappingArgs and KnowledgeBaseRdsFieldMappingOutput values. -// You can construct a concrete instance of `KnowledgeBaseRdsFieldMappingInput` via: +// KnowledgeBaseRedshiftServerlessConfigurationInput is an input type that accepts KnowledgeBaseRedshiftServerlessConfigurationArgs and KnowledgeBaseRedshiftServerlessConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftServerlessConfigurationInput` via: // -// KnowledgeBaseRdsFieldMappingArgs{...} -type KnowledgeBaseRdsFieldMappingInput interface { +// KnowledgeBaseRedshiftServerlessConfigurationArgs{...} +type KnowledgeBaseRedshiftServerlessConfigurationInput interface { pulumi.Input - ToKnowledgeBaseRdsFieldMappingOutput() KnowledgeBaseRdsFieldMappingOutput - ToKnowledgeBaseRdsFieldMappingOutputWithContext(context.Context) KnowledgeBaseRdsFieldMappingOutput + ToKnowledgeBaseRedshiftServerlessConfigurationOutput() KnowledgeBaseRedshiftServerlessConfigurationOutput + ToKnowledgeBaseRedshiftServerlessConfigurationOutputWithContext(context.Context) KnowledgeBaseRedshiftServerlessConfigurationOutput } -// Contains the names of the fields to which to map information about the vector store. -type KnowledgeBaseRdsFieldMappingArgs struct { - // The name of the field in which Amazon Bedrock stores metadata about the vector store. - MetadataField pulumi.StringInput `pulumi:"metadataField"` - // The name of the field in which Amazon Bedrock stores the ID for each entry. - PrimaryKeyField pulumi.StringInput `pulumi:"primaryKeyField"` - // The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose. - TextField pulumi.StringInput `pulumi:"textField"` - // The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources. - VectorField pulumi.StringInput `pulumi:"vectorField"` +// Configurations for serverless Redshift query engine +type KnowledgeBaseRedshiftServerlessConfigurationArgs struct { + AuthConfiguration KnowledgeBaseRedshiftServerlessAuthConfigurationInput `pulumi:"authConfiguration"` + WorkgroupArn pulumi.StringInput `pulumi:"workgroupArn"` } -func (KnowledgeBaseRdsFieldMappingArgs) ElementType() reflect.Type { - return reflect.TypeOf((*KnowledgeBaseRdsFieldMapping)(nil)).Elem() +func (KnowledgeBaseRedshiftServerlessConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftServerlessConfiguration)(nil)).Elem() } -func (i KnowledgeBaseRdsFieldMappingArgs) ToKnowledgeBaseRdsFieldMappingOutput() KnowledgeBaseRdsFieldMappingOutput { - return i.ToKnowledgeBaseRdsFieldMappingOutputWithContext(context.Background()) +func (i KnowledgeBaseRedshiftServerlessConfigurationArgs) ToKnowledgeBaseRedshiftServerlessConfigurationOutput() KnowledgeBaseRedshiftServerlessConfigurationOutput { + return i.ToKnowledgeBaseRedshiftServerlessConfigurationOutputWithContext(context.Background()) } -func (i KnowledgeBaseRdsFieldMappingArgs) ToKnowledgeBaseRdsFieldMappingOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingOutput { - return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsFieldMappingOutput) +func (i KnowledgeBaseRedshiftServerlessConfigurationArgs) ToKnowledgeBaseRedshiftServerlessConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftServerlessConfigurationOutput) } -func (i KnowledgeBaseRdsFieldMappingArgs) ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput { - return i.ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(context.Background()) +func (i KnowledgeBaseRedshiftServerlessConfigurationArgs) ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(context.Background()) } -func (i KnowledgeBaseRdsFieldMappingArgs) ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsFieldMappingOutput).ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx) +func (i KnowledgeBaseRedshiftServerlessConfigurationArgs) ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftServerlessConfigurationOutput).ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(ctx) } -// KnowledgeBaseRdsFieldMappingPtrInput is an input type that accepts KnowledgeBaseRdsFieldMappingArgs, KnowledgeBaseRdsFieldMappingPtr and KnowledgeBaseRdsFieldMappingPtrOutput values. -// You can construct a concrete instance of `KnowledgeBaseRdsFieldMappingPtrInput` via: +// KnowledgeBaseRedshiftServerlessConfigurationPtrInput is an input type that accepts KnowledgeBaseRedshiftServerlessConfigurationArgs, KnowledgeBaseRedshiftServerlessConfigurationPtr and KnowledgeBaseRedshiftServerlessConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseRedshiftServerlessConfigurationPtrInput` via: // -// KnowledgeBaseRdsFieldMappingArgs{...} +// KnowledgeBaseRedshiftServerlessConfigurationArgs{...} // // or: // // nil -type KnowledgeBaseRdsFieldMappingPtrInput interface { +type KnowledgeBaseRedshiftServerlessConfigurationPtrInput interface { pulumi.Input - ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput - ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(context.Context) KnowledgeBaseRdsFieldMappingPtrOutput + ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessConfigurationPtrOutput + ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseRedshiftServerlessConfigurationPtrOutput } -type knowledgeBaseRdsFieldMappingPtrType KnowledgeBaseRdsFieldMappingArgs +type knowledgeBaseRedshiftServerlessConfigurationPtrType KnowledgeBaseRedshiftServerlessConfigurationArgs -func KnowledgeBaseRdsFieldMappingPtr(v *KnowledgeBaseRdsFieldMappingArgs) KnowledgeBaseRdsFieldMappingPtrInput { - return (*knowledgeBaseRdsFieldMappingPtrType)(v) +func KnowledgeBaseRedshiftServerlessConfigurationPtr(v *KnowledgeBaseRedshiftServerlessConfigurationArgs) KnowledgeBaseRedshiftServerlessConfigurationPtrInput { + return (*knowledgeBaseRedshiftServerlessConfigurationPtrType)(v) } -func (*knowledgeBaseRdsFieldMappingPtrType) ElementType() reflect.Type { - return reflect.TypeOf((**KnowledgeBaseRdsFieldMapping)(nil)).Elem() +func (*knowledgeBaseRedshiftServerlessConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftServerlessConfiguration)(nil)).Elem() } -func (i *knowledgeBaseRdsFieldMappingPtrType) ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput { - return i.ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(context.Background()) +func (i *knowledgeBaseRedshiftServerlessConfigurationPtrType) ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { + return i.ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(context.Background()) } -func (i *knowledgeBaseRdsFieldMappingPtrType) ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingPtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRdsFieldMappingPtrOutput) +func (i *knowledgeBaseRedshiftServerlessConfigurationPtrType) ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) } -// Contains the names of the fields to which to map information about the vector store. -type KnowledgeBaseRdsFieldMappingOutput struct{ *pulumi.OutputState } +// Configurations for serverless Redshift query engine +type KnowledgeBaseRedshiftServerlessConfigurationOutput struct{ *pulumi.OutputState } -func (KnowledgeBaseRdsFieldMappingOutput) ElementType() reflect.Type { - return reflect.TypeOf((*KnowledgeBaseRdsFieldMapping)(nil)).Elem() +func (KnowledgeBaseRedshiftServerlessConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseRedshiftServerlessConfiguration)(nil)).Elem() } -func (o KnowledgeBaseRdsFieldMappingOutput) ToKnowledgeBaseRdsFieldMappingOutput() KnowledgeBaseRdsFieldMappingOutput { +func (o KnowledgeBaseRedshiftServerlessConfigurationOutput) ToKnowledgeBaseRedshiftServerlessConfigurationOutput() KnowledgeBaseRedshiftServerlessConfigurationOutput { return o } -func (o KnowledgeBaseRdsFieldMappingOutput) ToKnowledgeBaseRdsFieldMappingOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingOutput { +func (o KnowledgeBaseRedshiftServerlessConfigurationOutput) ToKnowledgeBaseRedshiftServerlessConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessConfigurationOutput { return o } -func (o KnowledgeBaseRdsFieldMappingOutput) ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput { - return o.ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(context.Background()) +func (o KnowledgeBaseRedshiftServerlessConfigurationOutput) ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { + return o.ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(context.Background()) } -func (o KnowledgeBaseRdsFieldMappingOutput) ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingPtrOutput { - return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRdsFieldMapping) *KnowledgeBaseRdsFieldMapping { +func (o KnowledgeBaseRedshiftServerlessConfigurationOutput) ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseRedshiftServerlessConfiguration) *KnowledgeBaseRedshiftServerlessConfiguration { return &v - }).(KnowledgeBaseRdsFieldMappingPtrOutput) -} - -// The name of the field in which Amazon Bedrock stores metadata about the vector store. -func (o KnowledgeBaseRdsFieldMappingOutput) MetadataField() pulumi.StringOutput { - return o.ApplyT(func(v KnowledgeBaseRdsFieldMapping) string { return v.MetadataField }).(pulumi.StringOutput) -} - -// The name of the field in which Amazon Bedrock stores the ID for each entry. -func (o KnowledgeBaseRdsFieldMappingOutput) PrimaryKeyField() pulumi.StringOutput { - return o.ApplyT(func(v KnowledgeBaseRdsFieldMapping) string { return v.PrimaryKeyField }).(pulumi.StringOutput) + }).(KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) } -// The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose. -func (o KnowledgeBaseRdsFieldMappingOutput) TextField() pulumi.StringOutput { - return o.ApplyT(func(v KnowledgeBaseRdsFieldMapping) string { return v.TextField }).(pulumi.StringOutput) +func (o KnowledgeBaseRedshiftServerlessConfigurationOutput) AuthConfiguration() KnowledgeBaseRedshiftServerlessAuthConfigurationOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftServerlessConfiguration) KnowledgeBaseRedshiftServerlessAuthConfiguration { + return v.AuthConfiguration + }).(KnowledgeBaseRedshiftServerlessAuthConfigurationOutput) } -// The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources. -func (o KnowledgeBaseRdsFieldMappingOutput) VectorField() pulumi.StringOutput { - return o.ApplyT(func(v KnowledgeBaseRdsFieldMapping) string { return v.VectorField }).(pulumi.StringOutput) +func (o KnowledgeBaseRedshiftServerlessConfigurationOutput) WorkgroupArn() pulumi.StringOutput { + return o.ApplyT(func(v KnowledgeBaseRedshiftServerlessConfiguration) string { return v.WorkgroupArn }).(pulumi.StringOutput) } -type KnowledgeBaseRdsFieldMappingPtrOutput struct{ *pulumi.OutputState } +type KnowledgeBaseRedshiftServerlessConfigurationPtrOutput struct{ *pulumi.OutputState } -func (KnowledgeBaseRdsFieldMappingPtrOutput) ElementType() reflect.Type { - return reflect.TypeOf((**KnowledgeBaseRdsFieldMapping)(nil)).Elem() +func (KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseRedshiftServerlessConfiguration)(nil)).Elem() } -func (o KnowledgeBaseRdsFieldMappingPtrOutput) ToKnowledgeBaseRdsFieldMappingPtrOutput() KnowledgeBaseRdsFieldMappingPtrOutput { +func (o KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutput() KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { return o } -func (o KnowledgeBaseRdsFieldMappingPtrOutput) ToKnowledgeBaseRdsFieldMappingPtrOutputWithContext(ctx context.Context) KnowledgeBaseRdsFieldMappingPtrOutput { +func (o KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) ToKnowledgeBaseRedshiftServerlessConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseRedshiftServerlessConfigurationPtrOutput { return o } -func (o KnowledgeBaseRdsFieldMappingPtrOutput) Elem() KnowledgeBaseRdsFieldMappingOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) KnowledgeBaseRdsFieldMapping { +func (o KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) Elem() KnowledgeBaseRedshiftServerlessConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftServerlessConfiguration) KnowledgeBaseRedshiftServerlessConfiguration { if v != nil { return *v } - var ret KnowledgeBaseRdsFieldMapping + var ret KnowledgeBaseRedshiftServerlessConfiguration return ret - }).(KnowledgeBaseRdsFieldMappingOutput) -} - -// The name of the field in which Amazon Bedrock stores metadata about the vector store. -func (o KnowledgeBaseRdsFieldMappingPtrOutput) MetadataField() pulumi.StringPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) *string { - if v == nil { - return nil - } - return &v.MetadataField - }).(pulumi.StringPtrOutput) -} - -// The name of the field in which Amazon Bedrock stores the ID for each entry. -func (o KnowledgeBaseRdsFieldMappingPtrOutput) PrimaryKeyField() pulumi.StringPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) *string { - if v == nil { - return nil - } - return &v.PrimaryKeyField - }).(pulumi.StringPtrOutput) + }).(KnowledgeBaseRedshiftServerlessConfigurationOutput) } -// The name of the field in which Amazon Bedrock stores the raw text from your data. The text is split according to the chunking strategy you choose. -func (o KnowledgeBaseRdsFieldMappingPtrOutput) TextField() pulumi.StringPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) *string { +func (o KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) AuthConfiguration() KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftServerlessConfiguration) *KnowledgeBaseRedshiftServerlessAuthConfiguration { if v == nil { return nil } - return &v.TextField - }).(pulumi.StringPtrOutput) + return &v.AuthConfiguration + }).(KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput) } -// The name of the field in which Amazon Bedrock stores the vector embeddings for your data sources. -func (o KnowledgeBaseRdsFieldMappingPtrOutput) VectorField() pulumi.StringPtrOutput { - return o.ApplyT(func(v *KnowledgeBaseRdsFieldMapping) *string { +func (o KnowledgeBaseRedshiftServerlessConfigurationPtrOutput) WorkgroupArn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseRedshiftServerlessConfiguration) *string { if v == nil { return nil } - return &v.VectorField + return &v.WorkgroupArn }).(pulumi.StringPtrOutput) } @@ -22311,6 +24377,159 @@ func (o KnowledgeBaseS3LocationPtrOutput) Uri() pulumi.StringPtrOutput { }).(pulumi.StringPtrOutput) } +// Configurations for a SQL knowledge base +type KnowledgeBaseSqlKnowledgeBaseConfiguration struct { + RedshiftConfiguration *KnowledgeBaseRedshiftConfiguration `pulumi:"redshiftConfiguration"` + Type KnowledgeBaseQueryEngineType `pulumi:"type"` +} + +// KnowledgeBaseSqlKnowledgeBaseConfigurationInput is an input type that accepts KnowledgeBaseSqlKnowledgeBaseConfigurationArgs and KnowledgeBaseSqlKnowledgeBaseConfigurationOutput values. +// You can construct a concrete instance of `KnowledgeBaseSqlKnowledgeBaseConfigurationInput` via: +// +// KnowledgeBaseSqlKnowledgeBaseConfigurationArgs{...} +type KnowledgeBaseSqlKnowledgeBaseConfigurationInput interface { + pulumi.Input + + ToKnowledgeBaseSqlKnowledgeBaseConfigurationOutput() KnowledgeBaseSqlKnowledgeBaseConfigurationOutput + ToKnowledgeBaseSqlKnowledgeBaseConfigurationOutputWithContext(context.Context) KnowledgeBaseSqlKnowledgeBaseConfigurationOutput +} + +// Configurations for a SQL knowledge base +type KnowledgeBaseSqlKnowledgeBaseConfigurationArgs struct { + RedshiftConfiguration KnowledgeBaseRedshiftConfigurationPtrInput `pulumi:"redshiftConfiguration"` + Type KnowledgeBaseQueryEngineTypeInput `pulumi:"type"` +} + +func (KnowledgeBaseSqlKnowledgeBaseConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseSqlKnowledgeBaseConfiguration)(nil)).Elem() +} + +func (i KnowledgeBaseSqlKnowledgeBaseConfigurationArgs) ToKnowledgeBaseSqlKnowledgeBaseConfigurationOutput() KnowledgeBaseSqlKnowledgeBaseConfigurationOutput { + return i.ToKnowledgeBaseSqlKnowledgeBaseConfigurationOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseSqlKnowledgeBaseConfigurationArgs) ToKnowledgeBaseSqlKnowledgeBaseConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseSqlKnowledgeBaseConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) +} + +func (i KnowledgeBaseSqlKnowledgeBaseConfigurationArgs) ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput() KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return i.ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(context.Background()) +} + +func (i KnowledgeBaseSqlKnowledgeBaseConfigurationArgs) ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseSqlKnowledgeBaseConfigurationOutput).ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(ctx) +} + +// KnowledgeBaseSqlKnowledgeBaseConfigurationPtrInput is an input type that accepts KnowledgeBaseSqlKnowledgeBaseConfigurationArgs, KnowledgeBaseSqlKnowledgeBaseConfigurationPtr and KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput values. +// You can construct a concrete instance of `KnowledgeBaseSqlKnowledgeBaseConfigurationPtrInput` via: +// +// KnowledgeBaseSqlKnowledgeBaseConfigurationArgs{...} +// +// or: +// +// nil +type KnowledgeBaseSqlKnowledgeBaseConfigurationPtrInput interface { + pulumi.Input + + ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput() KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput + ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(context.Context) KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput +} + +type knowledgeBaseSqlKnowledgeBaseConfigurationPtrType KnowledgeBaseSqlKnowledgeBaseConfigurationArgs + +func KnowledgeBaseSqlKnowledgeBaseConfigurationPtr(v *KnowledgeBaseSqlKnowledgeBaseConfigurationArgs) KnowledgeBaseSqlKnowledgeBaseConfigurationPtrInput { + return (*knowledgeBaseSqlKnowledgeBaseConfigurationPtrType)(v) +} + +func (*knowledgeBaseSqlKnowledgeBaseConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseSqlKnowledgeBaseConfiguration)(nil)).Elem() +} + +func (i *knowledgeBaseSqlKnowledgeBaseConfigurationPtrType) ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput() KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return i.ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *knowledgeBaseSqlKnowledgeBaseConfigurationPtrType) ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) +} + +// Configurations for a SQL knowledge base +type KnowledgeBaseSqlKnowledgeBaseConfigurationOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*KnowledgeBaseSqlKnowledgeBaseConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) ToKnowledgeBaseSqlKnowledgeBaseConfigurationOutput() KnowledgeBaseSqlKnowledgeBaseConfigurationOutput { + return o +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) ToKnowledgeBaseSqlKnowledgeBaseConfigurationOutputWithContext(ctx context.Context) KnowledgeBaseSqlKnowledgeBaseConfigurationOutput { + return o +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput() KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return o.ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(context.Background()) +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v KnowledgeBaseSqlKnowledgeBaseConfiguration) *KnowledgeBaseSqlKnowledgeBaseConfiguration { + return &v + }).(KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) RedshiftConfiguration() KnowledgeBaseRedshiftConfigurationPtrOutput { + return o.ApplyT(func(v KnowledgeBaseSqlKnowledgeBaseConfiguration) *KnowledgeBaseRedshiftConfiguration { + return v.RedshiftConfiguration + }).(KnowledgeBaseRedshiftConfigurationPtrOutput) +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) Type() KnowledgeBaseQueryEngineTypeOutput { + return o.ApplyT(func(v KnowledgeBaseSqlKnowledgeBaseConfiguration) KnowledgeBaseQueryEngineType { return v.Type }).(KnowledgeBaseQueryEngineTypeOutput) +} + +type KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KnowledgeBaseSqlKnowledgeBaseConfiguration)(nil)).Elem() +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput() KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) ToKnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutputWithContext(ctx context.Context) KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput { + return o +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) Elem() KnowledgeBaseSqlKnowledgeBaseConfigurationOutput { + return o.ApplyT(func(v *KnowledgeBaseSqlKnowledgeBaseConfiguration) KnowledgeBaseSqlKnowledgeBaseConfiguration { + if v != nil { + return *v + } + var ret KnowledgeBaseSqlKnowledgeBaseConfiguration + return ret + }).(KnowledgeBaseSqlKnowledgeBaseConfigurationOutput) +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) RedshiftConfiguration() KnowledgeBaseRedshiftConfigurationPtrOutput { + return o.ApplyT(func(v *KnowledgeBaseSqlKnowledgeBaseConfiguration) *KnowledgeBaseRedshiftConfiguration { + if v == nil { + return nil + } + return v.RedshiftConfiguration + }).(KnowledgeBaseRedshiftConfigurationPtrOutput) +} + +func (o KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput) Type() KnowledgeBaseQueryEngineTypePtrOutput { + return o.ApplyT(func(v *KnowledgeBaseSqlKnowledgeBaseConfiguration) *KnowledgeBaseQueryEngineType { + if v == nil { + return nil + } + return &v.Type + }).(KnowledgeBaseQueryEngineTypePtrOutput) +} + // The vector store service in which the knowledge base is stored. type KnowledgeBaseStorageConfiguration struct { // Contains the storage configuration of the knowledge base in MongoDB Atlas. @@ -26338,6 +28557,8 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseBedrockEmbeddingModelConfigurationInput)(nil)).Elem(), KnowledgeBaseBedrockEmbeddingModelConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseBedrockEmbeddingModelConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseBedrockEmbeddingModelConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseConfigurationInput)(nil)).Elem(), KnowledgeBaseConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseCuratedQueryInput)(nil)).Elem(), KnowledgeBaseCuratedQueryArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseCuratedQueryArrayInput)(nil)).Elem(), KnowledgeBaseCuratedQueryArray{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseEmbeddingModelConfigurationInput)(nil)).Elem(), KnowledgeBaseEmbeddingModelConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseEmbeddingModelConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseEmbeddingModelConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseKendraKnowledgeBaseConfigurationInput)(nil)).Elem(), KnowledgeBaseKendraKnowledgeBaseConfigurationArgs{}) @@ -26354,12 +28575,40 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBasePineconeConfigurationPtrInput)(nil)).Elem(), KnowledgeBasePineconeConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBasePineconeFieldMappingInput)(nil)).Elem(), KnowledgeBasePineconeFieldMappingArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBasePineconeFieldMappingPtrInput)(nil)).Elem(), KnowledgeBasePineconeFieldMappingArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryGenerationColumnInput)(nil)).Elem(), KnowledgeBaseQueryGenerationColumnArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryGenerationColumnArrayInput)(nil)).Elem(), KnowledgeBaseQueryGenerationColumnArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryGenerationConfigurationInput)(nil)).Elem(), KnowledgeBaseQueryGenerationConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryGenerationConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseQueryGenerationConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryGenerationContextInput)(nil)).Elem(), KnowledgeBaseQueryGenerationContextArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryGenerationContextPtrInput)(nil)).Elem(), KnowledgeBaseQueryGenerationContextArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryGenerationTableInput)(nil)).Elem(), KnowledgeBaseQueryGenerationTableArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseQueryGenerationTableArrayInput)(nil)).Elem(), KnowledgeBaseQueryGenerationTableArray{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRdsConfigurationInput)(nil)).Elem(), KnowledgeBaseRdsConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRdsConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRdsConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRdsFieldMappingInput)(nil)).Elem(), KnowledgeBaseRdsFieldMappingArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRdsFieldMappingPtrInput)(nil)).Elem(), KnowledgeBaseRdsFieldMappingArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRedshiftConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedAuthConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftProvisionedConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftProvisionedConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRedshiftProvisionedConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineStorageConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayInput)(nil)).Elem(), KnowledgeBaseRedshiftQueryEngineStorageConfigurationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftServerlessAuthConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftServerlessAuthConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftServerlessAuthConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRedshiftServerlessAuthConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftServerlessConfigurationInput)(nil)).Elem(), KnowledgeBaseRedshiftServerlessConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseRedshiftServerlessConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseRedshiftServerlessConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseS3LocationInput)(nil)).Elem(), KnowledgeBaseS3LocationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseS3LocationPtrInput)(nil)).Elem(), KnowledgeBaseS3LocationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseSqlKnowledgeBaseConfigurationInput)(nil)).Elem(), KnowledgeBaseSqlKnowledgeBaseConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseSqlKnowledgeBaseConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseSqlKnowledgeBaseConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseStorageConfigurationInput)(nil)).Elem(), KnowledgeBaseStorageConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseStorageConfigurationPtrInput)(nil)).Elem(), KnowledgeBaseStorageConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*KnowledgeBaseSupplementalDataStorageConfigurationInput)(nil)).Elem(), KnowledgeBaseSupplementalDataStorageConfigurationArgs{}) @@ -26743,6 +28992,9 @@ func init() { pulumi.RegisterOutputType(KnowledgeBaseBedrockEmbeddingModelConfigurationOutput{}) pulumi.RegisterOutputType(KnowledgeBaseBedrockEmbeddingModelConfigurationPtrOutput{}) pulumi.RegisterOutputType(KnowledgeBaseConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseCuratedQueryOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseCuratedQueryArrayOutput{}) pulumi.RegisterOutputType(KnowledgeBaseEmbeddingModelConfigurationOutput{}) pulumi.RegisterOutputType(KnowledgeBaseEmbeddingModelConfigurationPtrOutput{}) pulumi.RegisterOutputType(KnowledgeBaseKendraKnowledgeBaseConfigurationOutput{}) @@ -26759,12 +29011,40 @@ func init() { pulumi.RegisterOutputType(KnowledgeBasePineconeConfigurationPtrOutput{}) pulumi.RegisterOutputType(KnowledgeBasePineconeFieldMappingOutput{}) pulumi.RegisterOutputType(KnowledgeBasePineconeFieldMappingPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryGenerationColumnOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryGenerationColumnArrayOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryGenerationConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryGenerationConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryGenerationContextOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryGenerationContextPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryGenerationTableOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseQueryGenerationTableArrayOutput{}) pulumi.RegisterOutputType(KnowledgeBaseRdsConfigurationOutput{}) pulumi.RegisterOutputType(KnowledgeBaseRdsConfigurationPtrOutput{}) pulumi.RegisterOutputType(KnowledgeBaseRdsFieldMappingOutput{}) pulumi.RegisterOutputType(KnowledgeBaseRdsFieldMappingPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftProvisionedAuthConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftProvisionedAuthConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftProvisionedConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftProvisionedConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineStorageConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftQueryEngineStorageConfigurationArrayOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftServerlessAuthConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftServerlessAuthConfigurationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftServerlessConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseRedshiftServerlessConfigurationPtrOutput{}) pulumi.RegisterOutputType(KnowledgeBaseS3LocationOutput{}) pulumi.RegisterOutputType(KnowledgeBaseS3LocationPtrOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseSqlKnowledgeBaseConfigurationOutput{}) + pulumi.RegisterOutputType(KnowledgeBaseSqlKnowledgeBaseConfigurationPtrOutput{}) pulumi.RegisterOutputType(KnowledgeBaseStorageConfigurationOutput{}) pulumi.RegisterOutputType(KnowledgeBaseStorageConfigurationPtrOutput{}) pulumi.RegisterOutputType(KnowledgeBaseSupplementalDataStorageConfigurationOutput{}) diff --git a/sdk/go/aws/datazone/dataSource.go b/sdk/go/aws/datazone/dataSource.go index 620f05d3a0..e92cd8df28 100644 --- a/sdk/go/aws/datazone/dataSource.go +++ b/sdk/go/aws/datazone/dataSource.go @@ -22,6 +22,10 @@ type DataSource struct { AwsId pulumi.StringOutput `pulumi:"awsId"` // Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration. Configuration pulumi.AnyOutput `pulumi:"configuration"` + // The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + ConnectionId pulumi.StringOutput `pulumi:"connectionId"` + // The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + ConnectionIdentifier pulumi.StringPtrOutput `pulumi:"connectionIdentifier"` // The timestamp of when the data source was created. CreatedAt pulumi.StringOutput `pulumi:"createdAt"` // The description of the data source. @@ -35,7 +39,7 @@ type DataSource struct { // The unique identifier of the Amazon DataZone environment to which the data source publishes assets. EnvironmentId pulumi.StringOutput `pulumi:"environmentId"` // The unique identifier of the Amazon DataZone environment to which the data source publishes assets. - EnvironmentIdentifier pulumi.StringOutput `pulumi:"environmentIdentifier"` + EnvironmentIdentifier pulumi.StringPtrOutput `pulumi:"environmentIdentifier"` // The number of assets created by the data source during its last run. LastRunAssetCount pulumi.Float64Output `pulumi:"lastRunAssetCount"` // The timestamp that specifies when the data source was last run. @@ -72,9 +76,6 @@ func NewDataSource(ctx *pulumi.Context, if args.DomainIdentifier == nil { return nil, errors.New("invalid value for required argument 'DomainIdentifier'") } - if args.EnvironmentIdentifier == nil { - return nil, errors.New("invalid value for required argument 'EnvironmentIdentifier'") - } if args.ProjectIdentifier == nil { return nil, errors.New("invalid value for required argument 'ProjectIdentifier'") } @@ -82,6 +83,7 @@ func NewDataSource(ctx *pulumi.Context, return nil, errors.New("invalid value for required argument 'Type'") } replaceOnChanges := pulumi.ReplaceOnChanges([]string{ + "connectionIdentifier", "domainIdentifier", "environmentIdentifier", "projectIdentifier", @@ -125,6 +127,8 @@ type dataSourceArgs struct { AssetFormsInput []DataSourceFormInput `pulumi:"assetFormsInput"` // Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration. Configuration interface{} `pulumi:"configuration"` + // The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + ConnectionIdentifier *string `pulumi:"connectionIdentifier"` // The description of the data source. Description *string `pulumi:"description"` // The ID of the Amazon DataZone domain where the data source is created. @@ -132,7 +136,7 @@ type dataSourceArgs struct { // Specifies whether the data source is enabled. EnableSetting *DataSourceEnableSetting `pulumi:"enableSetting"` // The unique identifier of the Amazon DataZone environment to which the data source publishes assets. - EnvironmentIdentifier string `pulumi:"environmentIdentifier"` + EnvironmentIdentifier *string `pulumi:"environmentIdentifier"` // The name of the data source. Name *string `pulumi:"name"` // The identifier of the Amazon DataZone project in which you want to add the data source. @@ -153,6 +157,8 @@ type DataSourceArgs struct { AssetFormsInput DataSourceFormInputArrayInput // Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration. Configuration pulumi.Input + // The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + ConnectionIdentifier pulumi.StringPtrInput // The description of the data source. Description pulumi.StringPtrInput // The ID of the Amazon DataZone domain where the data source is created. @@ -160,7 +166,7 @@ type DataSourceArgs struct { // Specifies whether the data source is enabled. EnableSetting DataSourceEnableSettingPtrInput // The unique identifier of the Amazon DataZone environment to which the data source publishes assets. - EnvironmentIdentifier pulumi.StringInput + EnvironmentIdentifier pulumi.StringPtrInput // The name of the data source. Name pulumi.StringPtrInput // The identifier of the Amazon DataZone project in which you want to add the data source. @@ -227,6 +233,16 @@ func (o DataSourceOutput) Configuration() pulumi.AnyOutput { return o.ApplyT(func(v *DataSource) pulumi.AnyOutput { return v.Configuration }).(pulumi.AnyOutput) } +// The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run +func (o DataSourceOutput) ConnectionId() pulumi.StringOutput { + return o.ApplyT(func(v *DataSource) pulumi.StringOutput { return v.ConnectionId }).(pulumi.StringOutput) +} + +// The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run +func (o DataSourceOutput) ConnectionIdentifier() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DataSource) pulumi.StringPtrOutput { return v.ConnectionIdentifier }).(pulumi.StringPtrOutput) +} + // The timestamp of when the data source was created. func (o DataSourceOutput) CreatedAt() pulumi.StringOutput { return o.ApplyT(func(v *DataSource) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) @@ -258,8 +274,8 @@ func (o DataSourceOutput) EnvironmentId() pulumi.StringOutput { } // The unique identifier of the Amazon DataZone environment to which the data source publishes assets. -func (o DataSourceOutput) EnvironmentIdentifier() pulumi.StringOutput { - return o.ApplyT(func(v *DataSource) pulumi.StringOutput { return v.EnvironmentIdentifier }).(pulumi.StringOutput) +func (o DataSourceOutput) EnvironmentIdentifier() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DataSource) pulumi.StringPtrOutput { return v.EnvironmentIdentifier }).(pulumi.StringPtrOutput) } // The number of assets created by the data source during its last run. diff --git a/sdk/go/aws/datazone/getDataSource.go b/sdk/go/aws/datazone/getDataSource.go index cf896ad883..75b6e7985f 100644 --- a/sdk/go/aws/datazone/getDataSource.go +++ b/sdk/go/aws/datazone/getDataSource.go @@ -30,6 +30,8 @@ type LookupDataSourceArgs struct { } type LookupDataSourceResult struct { + // The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + ConnectionId *string `pulumi:"connectionId"` // The timestamp of when the data source was created. CreatedAt *string `pulumi:"createdAt"` // The description of the data source. @@ -98,6 +100,11 @@ func (o LookupDataSourceResultOutput) ToLookupDataSourceResultOutputWithContext( return o } +// The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run +func (o LookupDataSourceResultOutput) ConnectionId() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupDataSourceResult) *string { return v.ConnectionId }).(pulumi.StringPtrOutput) +} + // The timestamp of when the data source was created. func (o LookupDataSourceResultOutput) CreatedAt() pulumi.StringPtrOutput { return o.ApplyT(func(v LookupDataSourceResult) *string { return v.CreatedAt }).(pulumi.StringPtrOutput) diff --git a/sdk/go/aws/datazone/pulumiTypes.go b/sdk/go/aws/datazone/pulumiTypes.go index 0af4b715e6..3020aafacf 100644 --- a/sdk/go/aws/datazone/pulumiTypes.go +++ b/sdk/go/aws/datazone/pulumiTypes.go @@ -660,6 +660,8 @@ func (o DataSourceFormInputArrayOutput) Index(i pulumi.IntInput) DataSourceFormI type DataSourceGlueRunConfigurationInput struct { // Specifies whether to automatically import data quality metrics as part of the data source run. AutoImportDataQualityResult *bool `pulumi:"autoImportDataQualityResult"` + // The catalog name in the AWS Glue run configuration. + CatalogName *string `pulumi:"catalogName"` // The data access role included in the configuration details of the AWS Glue data source. DataAccessRole *string `pulumi:"dataAccessRole"` // The relational filter configurations included in the configuration details of the AWS Glue data source. @@ -680,6 +682,8 @@ type DataSourceGlueRunConfigurationInputInput interface { type DataSourceGlueRunConfigurationInputArgs struct { // Specifies whether to automatically import data quality metrics as part of the data source run. AutoImportDataQualityResult pulumi.BoolPtrInput `pulumi:"autoImportDataQualityResult"` + // The catalog name in the AWS Glue run configuration. + CatalogName pulumi.StringPtrInput `pulumi:"catalogName"` // The data access role included in the configuration details of the AWS Glue data source. DataAccessRole pulumi.StringPtrInput `pulumi:"dataAccessRole"` // The relational filter configurations included in the configuration details of the AWS Glue data source. @@ -768,6 +772,11 @@ func (o DataSourceGlueRunConfigurationInputOutput) AutoImportDataQualityResult() return o.ApplyT(func(v DataSourceGlueRunConfigurationInput) *bool { return v.AutoImportDataQualityResult }).(pulumi.BoolPtrOutput) } +// The catalog name in the AWS Glue run configuration. +func (o DataSourceGlueRunConfigurationInputOutput) CatalogName() pulumi.StringPtrOutput { + return o.ApplyT(func(v DataSourceGlueRunConfigurationInput) *string { return v.CatalogName }).(pulumi.StringPtrOutput) +} + // The data access role included in the configuration details of the AWS Glue data source. func (o DataSourceGlueRunConfigurationInputOutput) DataAccessRole() pulumi.StringPtrOutput { return o.ApplyT(func(v DataSourceGlueRunConfigurationInput) *string { return v.DataAccessRole }).(pulumi.StringPtrOutput) @@ -814,6 +823,16 @@ func (o DataSourceGlueRunConfigurationInputPtrOutput) AutoImportDataQualityResul }).(pulumi.BoolPtrOutput) } +// The catalog name in the AWS Glue run configuration. +func (o DataSourceGlueRunConfigurationInputPtrOutput) CatalogName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DataSourceGlueRunConfigurationInput) *string { + if v == nil { + return nil + } + return v.CatalogName + }).(pulumi.StringPtrOutput) +} + // The data access role included in the configuration details of the AWS Glue data source. func (o DataSourceGlueRunConfigurationInputPtrOutput) DataAccessRole() pulumi.StringPtrOutput { return o.ApplyT(func(v *DataSourceGlueRunConfigurationInput) *string { @@ -1259,7 +1278,7 @@ type DataSourceRedshiftRunConfigurationInput struct { // The data access role included in the configuration details of the Amazon Redshift data source. DataAccessRole *string `pulumi:"dataAccessRole"` // The details of the credentials required to access an Amazon Redshift cluster. - RedshiftCredentialConfiguration DataSourceRedshiftCredentialConfiguration `pulumi:"redshiftCredentialConfiguration"` + RedshiftCredentialConfiguration *DataSourceRedshiftCredentialConfiguration `pulumi:"redshiftCredentialConfiguration"` // The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. RedshiftStorage interface{} `pulumi:"redshiftStorage"` RelationalFilterConfigurations []DataSourceRelationalFilterConfiguration `pulumi:"relationalFilterConfigurations"` @@ -1281,7 +1300,7 @@ type DataSourceRedshiftRunConfigurationInputArgs struct { // The data access role included in the configuration details of the Amazon Redshift data source. DataAccessRole pulumi.StringPtrInput `pulumi:"dataAccessRole"` // The details of the credentials required to access an Amazon Redshift cluster. - RedshiftCredentialConfiguration DataSourceRedshiftCredentialConfigurationInput `pulumi:"redshiftCredentialConfiguration"` + RedshiftCredentialConfiguration DataSourceRedshiftCredentialConfigurationPtrInput `pulumi:"redshiftCredentialConfiguration"` // The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. RedshiftStorage pulumi.Input `pulumi:"redshiftStorage"` RelationalFilterConfigurations DataSourceRelationalFilterConfigurationArrayInput `pulumi:"relationalFilterConfigurations"` @@ -1371,10 +1390,10 @@ func (o DataSourceRedshiftRunConfigurationInputOutput) DataAccessRole() pulumi.S } // The details of the credentials required to access an Amazon Redshift cluster. -func (o DataSourceRedshiftRunConfigurationInputOutput) RedshiftCredentialConfiguration() DataSourceRedshiftCredentialConfigurationOutput { - return o.ApplyT(func(v DataSourceRedshiftRunConfigurationInput) DataSourceRedshiftCredentialConfiguration { +func (o DataSourceRedshiftRunConfigurationInputOutput) RedshiftCredentialConfiguration() DataSourceRedshiftCredentialConfigurationPtrOutput { + return o.ApplyT(func(v DataSourceRedshiftRunConfigurationInput) *DataSourceRedshiftCredentialConfiguration { return v.RedshiftCredentialConfiguration - }).(DataSourceRedshiftCredentialConfigurationOutput) + }).(DataSourceRedshiftCredentialConfigurationPtrOutput) } // The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. @@ -1428,7 +1447,7 @@ func (o DataSourceRedshiftRunConfigurationInputPtrOutput) RedshiftCredentialConf if v == nil { return nil } - return &v.RedshiftCredentialConfiguration + return v.RedshiftCredentialConfiguration }).(DataSourceRedshiftCredentialConfigurationPtrOutput) } diff --git a/sdk/go/aws/iot/pulumiTypes.go b/sdk/go/aws/iot/pulumiTypes.go index e5dc57ca34..abfcf9b9f9 100644 --- a/sdk/go/aws/iot/pulumiTypes.go +++ b/sdk/go/aws/iot/pulumiTypes.go @@ -7534,9 +7534,9 @@ func (o ThingTypePropertiesPropertiesMqtt5ConfigurationPropertiesPtrOutput) Prop // A key-value pair to associate with a resource. type ThingTypeTag struct { - // The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. + // Tag key (1-128 chars). No 'aws:' prefix. Allows: [A-Za-z0-9 _.:/=+-] Key string `pulumi:"key"` - // The value for the tag. You can specify a value that is 1 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -. + // Tag value (1-256 chars). No 'aws:' prefix. Allows: [A-Za-z0-9 _.:/=+-] Value string `pulumi:"value"` } diff --git a/sdk/go/aws/pulumiEnums.go b/sdk/go/aws/pulumiEnums.go index fbc5d7032e..9c339150fb 100644 --- a/sdk/go/aws/pulumiEnums.go +++ b/sdk/go/aws/pulumiEnums.go @@ -65,6 +65,8 @@ const ( RegionMeCentral1 = Region("me-central-1") // Middle East (Bahrain) RegionMeSouth1 = Region("me-south-1") + // Mexico (Central) + RegionMxCentral1 = Region("mx-central-1") // South America (Sao Paulo) RegionSaEast1 = Region("sa-east-1") // US East (N. Virginia) diff --git a/sdk/go/aws/rds/dbInstance.go b/sdk/go/aws/rds/dbInstance.go index 8f0e87f364..b442b54bd4 100644 --- a/sdk/go/aws/rds/dbInstance.go +++ b/sdk/go/aws/rds/dbInstance.go @@ -144,11 +144,7 @@ type DbInstance struct { // // For the list of permissions required for the IAM role, see [Configure IAM and your VPC](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/custom-setup-orcl.html#custom-setup-orcl.iam-vpc) in the *Amazon RDS User Guide*. CustomIamInstanceProfile pulumi.StringPtrOutput `pulumi:"customIamInstanceProfile"` - // The mode of Database Insights to enable for the DB instance. - // - // This setting only applies to Amazon Aurora DB instances. - // - // > Currently, this value is inherited from the DB cluster and can't be changed. + // The mode of Database Insights that is enabled for the instance. DatabaseInsightsMode pulumi.StringOutput `pulumi:"databaseInsightsMode"` // The identifier of the DB cluster that this DB instance will belong to. // This setting doesn't apply to RDS Custom DB instances. @@ -2116,11 +2112,7 @@ func (o DbInstanceOutput) CustomIamInstanceProfile() pulumi.StringPtrOutput { return o.ApplyT(func(v *DbInstance) pulumi.StringPtrOutput { return v.CustomIamInstanceProfile }).(pulumi.StringPtrOutput) } -// The mode of Database Insights to enable for the DB instance. -// -// This setting only applies to Amazon Aurora DB instances. -// -// > Currently, this value is inherited from the DB cluster and can't be changed. +// The mode of Database Insights that is enabled for the instance. func (o DbInstanceOutput) DatabaseInsightsMode() pulumi.StringOutput { return o.ApplyT(func(v *DbInstance) pulumi.StringOutput { return v.DatabaseInsightsMode }).(pulumi.StringOutput) } diff --git a/sdk/go/aws/rds/getDbInstance.go b/sdk/go/aws/rds/getDbInstance.go index 8e8a6f1f7b..822ec95a0f 100644 --- a/sdk/go/aws/rds/getDbInstance.go +++ b/sdk/go/aws/rds/getDbInstance.go @@ -132,11 +132,7 @@ type LookupDbInstanceResult struct { // Specifies whether to copy tags from the DB instance to snapshots of the DB instance. By default, tags are not copied. // This setting doesn't apply to Amazon Aurora DB instances. Copying tags to snapshots is managed by the DB cluster. Setting this value for an Aurora DB instance has no effect on the DB cluster setting. CopyTagsToSnapshot *bool `pulumi:"copyTagsToSnapshot"` - // The mode of Database Insights to enable for the DB instance. - // - // This setting only applies to Amazon Aurora DB instances. - // - // > Currently, this value is inherited from the DB cluster and can't be changed. + // The mode of Database Insights that is enabled for the instance. DatabaseInsightsMode *string `pulumi:"databaseInsightsMode"` // The identifier for the Multi-AZ DB cluster snapshot to restore from. // For more information on Multi-AZ DB clusters, see [Multi-AZ DB cluster deployments](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/multi-az-db-clusters-concepts.html) in the *Amazon RDS User Guide*. @@ -598,11 +594,7 @@ func (o LookupDbInstanceResultOutput) CopyTagsToSnapshot() pulumi.BoolPtrOutput return o.ApplyT(func(v LookupDbInstanceResult) *bool { return v.CopyTagsToSnapshot }).(pulumi.BoolPtrOutput) } -// The mode of Database Insights to enable for the DB instance. -// -// This setting only applies to Amazon Aurora DB instances. -// -// > Currently, this value is inherited from the DB cluster and can't be changed. +// The mode of Database Insights that is enabled for the instance. func (o LookupDbInstanceResultOutput) DatabaseInsightsMode() pulumi.StringPtrOutput { return o.ApplyT(func(v LookupDbInstanceResult) *string { return v.DatabaseInsightsMode }).(pulumi.StringPtrOutput) } diff --git a/sdk/go/aws/sns/getTopic.go b/sdk/go/aws/sns/getTopic.go index 2a252c2a50..59c7b65d10 100644 --- a/sdk/go/aws/sns/getTopic.go +++ b/sdk/go/aws/sns/getTopic.go @@ -58,7 +58,8 @@ type LookupTopicResult struct { // Once configured, log entries are sent to Amazon CloudWatch Logs. DeliveryStatusLogging []TopicLoggingConfig `pulumi:"deliveryStatusLogging"` // The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs. - DisplayName *string `pulumi:"displayName"` + DisplayName *string `pulumi:"displayName"` + FifoThroughputScope *string `pulumi:"fifoThroughputScope"` // The ID of an AWS managed customer master key (CMK) for SNS or a custom CMK. For more information, see [Key terms](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms). For more examples, see ``KeyId`` in the *API Reference*. // This property applies only to [server-side-encryption](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html). KmsMasterKeyId *string `pulumi:"kmsMasterKeyId"` @@ -156,6 +157,10 @@ func (o LookupTopicResultOutput) DisplayName() pulumi.StringPtrOutput { return o.ApplyT(func(v LookupTopicResult) *string { return v.DisplayName }).(pulumi.StringPtrOutput) } +func (o LookupTopicResultOutput) FifoThroughputScope() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupTopicResult) *string { return v.FifoThroughputScope }).(pulumi.StringPtrOutput) +} + // The ID of an AWS managed customer master key (CMK) for SNS or a custom CMK. For more information, see [Key terms](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms). For more examples, see “KeyId“ in the *API Reference*. // // This property applies only to [server-side-encryption](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html). diff --git a/sdk/go/aws/sns/topic.go b/sdk/go/aws/sns/topic.go index 0f3fa1e4e5..cd57e00765 100644 --- a/sdk/go/aws/sns/topic.go +++ b/sdk/go/aws/sns/topic.go @@ -201,7 +201,8 @@ type Topic struct { // Once configured, log entries are sent to Amazon CloudWatch Logs. DeliveryStatusLogging TopicLoggingConfigArrayOutput `pulumi:"deliveryStatusLogging"` // The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs. - DisplayName pulumi.StringPtrOutput `pulumi:"displayName"` + DisplayName pulumi.StringPtrOutput `pulumi:"displayName"` + FifoThroughputScope pulumi.StringPtrOutput `pulumi:"fifoThroughputScope"` // Set to true to create a FIFO topic. FifoTopic pulumi.BoolPtrOutput `pulumi:"fifoTopic"` // The ID of an AWS managed customer master key (CMK) for SNS or a custom CMK. For more information, see [Key terms](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms). For more examples, see ``KeyId`` in the *API Reference*. @@ -296,7 +297,8 @@ type topicArgs struct { // Once configured, log entries are sent to Amazon CloudWatch Logs. DeliveryStatusLogging []TopicLoggingConfig `pulumi:"deliveryStatusLogging"` // The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs. - DisplayName *string `pulumi:"displayName"` + DisplayName *string `pulumi:"displayName"` + FifoThroughputScope *string `pulumi:"fifoThroughputScope"` // Set to true to create a FIFO topic. FifoTopic *bool `pulumi:"fifoTopic"` // The ID of an AWS managed customer master key (CMK) for SNS or a custom CMK. For more information, see [Key terms](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms). For more examples, see ``KeyId`` in the *API Reference*. @@ -346,7 +348,8 @@ type TopicArgs struct { // Once configured, log entries are sent to Amazon CloudWatch Logs. DeliveryStatusLogging TopicLoggingConfigArrayInput // The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs. - DisplayName pulumi.StringPtrInput + DisplayName pulumi.StringPtrInput + FifoThroughputScope pulumi.StringPtrInput // Set to true to create a FIFO topic. FifoTopic pulumi.BoolPtrInput // The ID of an AWS managed customer master key (CMK) for SNS or a custom CMK. For more information, see [Key terms](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms). For more examples, see ``KeyId`` in the *API Reference*. @@ -453,6 +456,10 @@ func (o TopicOutput) DisplayName() pulumi.StringPtrOutput { return o.ApplyT(func(v *Topic) pulumi.StringPtrOutput { return v.DisplayName }).(pulumi.StringPtrOutput) } +func (o TopicOutput) FifoThroughputScope() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Topic) pulumi.StringPtrOutput { return v.FifoThroughputScope }).(pulumi.StringPtrOutput) +} + // Set to true to create a FIFO topic. func (o TopicOutput) FifoTopic() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Topic) pulumi.BoolPtrOutput { return v.FifoTopic }).(pulumi.BoolPtrOutput) diff --git a/sdk/go/aws/ssm/association.go b/sdk/go/aws/ssm/association.go index ef8dca5050..22233be1d5 100644 --- a/sdk/go/aws/ssm/association.go +++ b/sdk/go/aws/ssm/association.go @@ -245,7 +245,7 @@ type Association struct { AssociationId pulumi.StringOutput `pulumi:"associationId"` // The name of the association. AssociationName pulumi.StringPtrOutput `pulumi:"associationName"` - // Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + // Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . AutomationTargetParameterName pulumi.StringPtrOutput `pulumi:"automationTargetParameterName"` // The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see [AWS Systems Manager Change Calendar](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar) . CalendarNames pulumi.StringArrayOutput `pulumi:"calendarNames"` @@ -331,7 +331,7 @@ type associationArgs struct { ApplyOnlyAtCronInterval *bool `pulumi:"applyOnlyAtCronInterval"` // The name of the association. AssociationName *string `pulumi:"associationName"` - // Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + // Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . AutomationTargetParameterName *string `pulumi:"automationTargetParameterName"` // The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see [AWS Systems Manager Change Calendar](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar) . CalendarNames []string `pulumi:"calendarNames"` @@ -379,7 +379,7 @@ type AssociationArgs struct { ApplyOnlyAtCronInterval pulumi.BoolPtrInput // The name of the association. AssociationName pulumi.StringPtrInput - // Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + // Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . AutomationTargetParameterName pulumi.StringPtrInput // The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see [AWS Systems Manager Change Calendar](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar) . CalendarNames pulumi.StringArrayInput @@ -473,7 +473,7 @@ func (o AssociationOutput) AssociationName() pulumi.StringPtrOutput { return o.ApplyT(func(v *Association) pulumi.StringPtrOutput { return v.AssociationName }).(pulumi.StringPtrOutput) } -// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . +// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . func (o AssociationOutput) AutomationTargetParameterName() pulumi.StringPtrOutput { return o.ApplyT(func(v *Association) pulumi.StringPtrOutput { return v.AutomationTargetParameterName }).(pulumi.StringPtrOutput) } diff --git a/sdk/go/aws/ssm/getAssociation.go b/sdk/go/aws/ssm/getAssociation.go index c5e66c8af3..96ea2b5511 100644 --- a/sdk/go/aws/ssm/getAssociation.go +++ b/sdk/go/aws/ssm/getAssociation.go @@ -34,7 +34,7 @@ type LookupAssociationResult struct { AssociationId *string `pulumi:"associationId"` // The name of the association. AssociationName *string `pulumi:"associationName"` - // Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + // Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . AutomationTargetParameterName *string `pulumi:"automationTargetParameterName"` // The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see [AWS Systems Manager Change Calendar](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar) . CalendarNames []string `pulumi:"calendarNames"` @@ -119,7 +119,7 @@ func (o LookupAssociationResultOutput) AssociationName() pulumi.StringPtrOutput return o.ApplyT(func(v LookupAssociationResult) *string { return v.AssociationName }).(pulumi.StringPtrOutput) } -// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . +// Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . func (o LookupAssociationResultOutput) AutomationTargetParameterName() pulumi.StringPtrOutput { return o.ApplyT(func(v LookupAssociationResult) *string { return v.AutomationTargetParameterName }).(pulumi.StringPtrOutput) } diff --git a/sdk/nodejs/bedrock/getKnowledgeBase.ts b/sdk/nodejs/bedrock/getKnowledgeBase.ts index 22ce362afa..fec44ee585 100644 --- a/sdk/nodejs/bedrock/getKnowledgeBase.ts +++ b/sdk/nodejs/bedrock/getKnowledgeBase.ts @@ -41,6 +41,10 @@ export interface GetKnowledgeBaseResult { * The ARN of the knowledge base. */ readonly knowledgeBaseArn?: string; + /** + * Contains details about the embeddings configuration of the knowledge base. + */ + readonly knowledgeBaseConfiguration?: outputs.bedrock.KnowledgeBaseConfiguration; /** * The unique identifier of the knowledge base. */ diff --git a/sdk/nodejs/bedrock/knowledgeBase.ts b/sdk/nodejs/bedrock/knowledgeBase.ts index 4c970f2c85..5b4203b081 100644 --- a/sdk/nodejs/bedrock/knowledgeBase.ts +++ b/sdk/nodejs/bedrock/knowledgeBase.ts @@ -133,7 +133,7 @@ export class KnowledgeBase extends pulumi.CustomResource { resourceInputs["updatedAt"] = undefined /*out*/; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); - const replaceOnChanges = { replaceOnChanges: ["knowledgeBaseConfiguration", "storageConfiguration"] }; + const replaceOnChanges = { replaceOnChanges: ["knowledgeBaseConfiguration.kendraKnowledgeBaseConfiguration", "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.redshiftConfiguration.queryEngineConfiguration", "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.redshiftConfiguration.storageConfigurations[*]", "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.type", "knowledgeBaseConfiguration.type", "knowledgeBaseConfiguration.vectorKnowledgeBaseConfiguration", "storageConfiguration"] }; opts = pulumi.mergeOptions(opts, replaceOnChanges); super(KnowledgeBase.__pulumiType, name, resourceInputs, opts); } diff --git a/sdk/nodejs/datazone/dataSource.ts b/sdk/nodejs/datazone/dataSource.ts index 09127098f7..45bc4f3a3f 100644 --- a/sdk/nodejs/datazone/dataSource.ts +++ b/sdk/nodejs/datazone/dataSource.ts @@ -49,6 +49,14 @@ export class DataSource extends pulumi.CustomResource { * Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration. */ public readonly configuration!: pulumi.Output; + /** + * The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + */ + public /*out*/ readonly connectionId!: pulumi.Output; + /** + * The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + */ + public readonly connectionIdentifier!: pulumi.Output; /** * The timestamp of when the data source was created. */ @@ -76,7 +84,7 @@ export class DataSource extends pulumi.CustomResource { /** * The unique identifier of the Amazon DataZone environment to which the data source publishes assets. */ - public readonly environmentIdentifier!: pulumi.Output; + public readonly environmentIdentifier!: pulumi.Output; /** * The number of assets created by the data source during its last run. */ @@ -140,9 +148,6 @@ export class DataSource extends pulumi.CustomResource { if ((!args || args.domainIdentifier === undefined) && !opts.urn) { throw new Error("Missing required property 'domainIdentifier'"); } - if ((!args || args.environmentIdentifier === undefined) && !opts.urn) { - throw new Error("Missing required property 'environmentIdentifier'"); - } if ((!args || args.projectIdentifier === undefined) && !opts.urn) { throw new Error("Missing required property 'projectIdentifier'"); } @@ -151,6 +156,7 @@ export class DataSource extends pulumi.CustomResource { } resourceInputs["assetFormsInput"] = args ? args.assetFormsInput : undefined; resourceInputs["configuration"] = args ? args.configuration : undefined; + resourceInputs["connectionIdentifier"] = args ? args.connectionIdentifier : undefined; resourceInputs["description"] = args ? args.description : undefined; resourceInputs["domainIdentifier"] = args ? args.domainIdentifier : undefined; resourceInputs["enableSetting"] = args ? args.enableSetting : undefined; @@ -162,6 +168,7 @@ export class DataSource extends pulumi.CustomResource { resourceInputs["schedule"] = args ? args.schedule : undefined; resourceInputs["type"] = args ? args.type : undefined; resourceInputs["awsId"] = undefined /*out*/; + resourceInputs["connectionId"] = undefined /*out*/; resourceInputs["createdAt"] = undefined /*out*/; resourceInputs["domainId"] = undefined /*out*/; resourceInputs["environmentId"] = undefined /*out*/; @@ -175,6 +182,8 @@ export class DataSource extends pulumi.CustomResource { resourceInputs["assetFormsInput"] = undefined /*out*/; resourceInputs["awsId"] = undefined /*out*/; resourceInputs["configuration"] = undefined /*out*/; + resourceInputs["connectionId"] = undefined /*out*/; + resourceInputs["connectionIdentifier"] = undefined /*out*/; resourceInputs["createdAt"] = undefined /*out*/; resourceInputs["description"] = undefined /*out*/; resourceInputs["domainId"] = undefined /*out*/; @@ -196,7 +205,7 @@ export class DataSource extends pulumi.CustomResource { resourceInputs["updatedAt"] = undefined /*out*/; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); - const replaceOnChanges = { replaceOnChanges: ["domainIdentifier", "environmentIdentifier", "projectIdentifier", "type"] }; + const replaceOnChanges = { replaceOnChanges: ["connectionIdentifier", "domainIdentifier", "environmentIdentifier", "projectIdentifier", "type"] }; opts = pulumi.mergeOptions(opts, replaceOnChanges); super(DataSource.__pulumiType, name, resourceInputs, opts); } @@ -214,6 +223,10 @@ export interface DataSourceArgs { * Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration. */ configuration?: pulumi.Input; + /** + * The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + */ + connectionIdentifier?: pulumi.Input; /** * The description of the data source. */ @@ -229,7 +242,7 @@ export interface DataSourceArgs { /** * The unique identifier of the Amazon DataZone environment to which the data source publishes assets. */ - environmentIdentifier: pulumi.Input; + environmentIdentifier?: pulumi.Input; /** * The name of the data source. */ diff --git a/sdk/nodejs/datazone/getDataSource.ts b/sdk/nodejs/datazone/getDataSource.ts index 4e3bcb95d5..60d0ea4607 100644 --- a/sdk/nodejs/datazone/getDataSource.ts +++ b/sdk/nodejs/datazone/getDataSource.ts @@ -30,6 +30,10 @@ export interface GetDataSourceArgs { } export interface GetDataSourceResult { + /** + * The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + */ + readonly connectionId?: string; /** * The timestamp of when the data source was created. */ diff --git a/sdk/nodejs/rds/dbInstance.ts b/sdk/nodejs/rds/dbInstance.ts index f678edf211..b595d8eecd 100644 --- a/sdk/nodejs/rds/dbInstance.ts +++ b/sdk/nodejs/rds/dbInstance.ts @@ -193,11 +193,7 @@ export class DbInstance extends pulumi.CustomResource { */ public readonly customIamInstanceProfile!: pulumi.Output; /** - * The mode of Database Insights to enable for the DB instance. - * - * This setting only applies to Amazon Aurora DB instances. - * - * > Currently, this value is inherited from the DB cluster and can't be changed. + * The mode of Database Insights that is enabled for the instance. */ public /*out*/ readonly databaseInsightsMode!: pulumi.Output; /** diff --git a/sdk/nodejs/rds/getDbInstance.ts b/sdk/nodejs/rds/getDbInstance.ts index 197472380c..d82a1b2d37 100644 --- a/sdk/nodejs/rds/getDbInstance.ts +++ b/sdk/nodejs/rds/getDbInstance.ts @@ -146,11 +146,7 @@ export interface GetDbInstanceResult { */ readonly copyTagsToSnapshot?: boolean; /** - * The mode of Database Insights to enable for the DB instance. - * - * This setting only applies to Amazon Aurora DB instances. - * - * > Currently, this value is inherited from the DB cluster and can't be changed. + * The mode of Database Insights that is enabled for the instance. */ readonly databaseInsightsMode?: string; /** diff --git a/sdk/nodejs/sns/getTopic.ts b/sdk/nodejs/sns/getTopic.ts index 4b79139cdb..3dc4c3b2e2 100644 --- a/sdk/nodejs/sns/getTopic.ts +++ b/sdk/nodejs/sns/getTopic.ts @@ -64,6 +64,7 @@ export interface GetTopicResult { * The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs. */ readonly displayName?: string; + readonly fifoThroughputScope?: string; /** * The ID of an AWS managed customer master key (CMK) for SNS or a custom CMK. For more information, see [Key terms](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html#sse-key-terms). For more examples, see ``KeyId`` in the *API Reference*. * This property applies only to [server-side-encryption](https://docs.aws.amazon.com/sns/latest/dg/sns-server-side-encryption.html). diff --git a/sdk/nodejs/sns/topic.ts b/sdk/nodejs/sns/topic.ts index 38f7b37719..a6fac73fd8 100644 --- a/sdk/nodejs/sns/topic.ts +++ b/sdk/nodejs/sns/topic.ts @@ -166,6 +166,7 @@ export class Topic extends pulumi.CustomResource { * The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs. */ public readonly displayName!: pulumi.Output; + public readonly fifoThroughputScope!: pulumi.Output; /** * Set to true to create a FIFO topic. */ @@ -220,6 +221,7 @@ export class Topic extends pulumi.CustomResource { resourceInputs["dataProtectionPolicy"] = args ? args.dataProtectionPolicy : undefined; resourceInputs["deliveryStatusLogging"] = args ? args.deliveryStatusLogging : undefined; resourceInputs["displayName"] = args ? args.displayName : undefined; + resourceInputs["fifoThroughputScope"] = args ? args.fifoThroughputScope : undefined; resourceInputs["fifoTopic"] = args ? args.fifoTopic : undefined; resourceInputs["kmsMasterKeyId"] = args ? args.kmsMasterKeyId : undefined; resourceInputs["signatureVersion"] = args ? args.signatureVersion : undefined; @@ -234,6 +236,7 @@ export class Topic extends pulumi.CustomResource { resourceInputs["dataProtectionPolicy"] = undefined /*out*/; resourceInputs["deliveryStatusLogging"] = undefined /*out*/; resourceInputs["displayName"] = undefined /*out*/; + resourceInputs["fifoThroughputScope"] = undefined /*out*/; resourceInputs["fifoTopic"] = undefined /*out*/; resourceInputs["kmsMasterKeyId"] = undefined /*out*/; resourceInputs["signatureVersion"] = undefined /*out*/; @@ -291,6 +294,7 @@ export interface TopicArgs { * The display name to use for an SNS topic with SMS subscriptions. The display name must be maximum 100 characters long, including hyphens (-), underscores (_), spaces, and tabs. */ displayName?: pulumi.Input; + fifoThroughputScope?: pulumi.Input; /** * Set to true to create a FIFO topic. */ diff --git a/sdk/nodejs/ssm/association.ts b/sdk/nodejs/ssm/association.ts index 903799d196..cd8026c6bd 100644 --- a/sdk/nodejs/ssm/association.ts +++ b/sdk/nodejs/ssm/association.ts @@ -158,7 +158,7 @@ export class Association extends pulumi.CustomResource { */ public readonly associationName!: pulumi.Output; /** - * Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + * Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . */ public readonly automationTargetParameterName!: pulumi.Output; /** @@ -295,7 +295,7 @@ export interface AssociationArgs { */ associationName?: pulumi.Input; /** - * Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + * Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . */ automationTargetParameterName?: pulumi.Input; /** diff --git a/sdk/nodejs/ssm/getAssociation.ts b/sdk/nodejs/ssm/getAssociation.ts index 16913ddeb0..f0483a7244 100644 --- a/sdk/nodejs/ssm/getAssociation.ts +++ b/sdk/nodejs/ssm/getAssociation.ts @@ -38,7 +38,7 @@ export interface GetAssociationResult { */ readonly associationName?: string; /** - * Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + * Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . */ readonly automationTargetParameterName?: string; /** diff --git a/sdk/nodejs/types/enums/bedrock/index.ts b/sdk/nodejs/types/enums/bedrock/index.ts index fa957ca065..7a6d79df8a 100644 --- a/sdk/nodejs/types/enums/bedrock/index.ts +++ b/sdk/nodejs/types/enums/bedrock/index.ts @@ -267,6 +267,7 @@ export const DataSourceType = { Sharepoint: "SHAREPOINT", Web: "WEB", Custom: "CUSTOM", + RedshiftMetadata: "REDSHIFT_METADATA", } as const; /** @@ -529,6 +530,66 @@ export const GuardrailTopicType = { */ export type GuardrailTopicType = (typeof GuardrailTopicType)[keyof typeof GuardrailTopicType]; +export const KnowledgeBaseInclusionType = { + Include: "INCLUDE", + Exclude: "EXCLUDE", +} as const; + +/** + * Include or Exclude status for an entity + */ +export type KnowledgeBaseInclusionType = (typeof KnowledgeBaseInclusionType)[keyof typeof KnowledgeBaseInclusionType]; + +export const KnowledgeBaseQueryEngineType = { + Redshift: "REDSHIFT", +} as const; + +/** + * SQL query engine type + */ +export type KnowledgeBaseQueryEngineType = (typeof KnowledgeBaseQueryEngineType)[keyof typeof KnowledgeBaseQueryEngineType]; + +export const KnowledgeBaseRedshiftProvisionedAuthType = { + Iam: "IAM", + UsernamePassword: "USERNAME_PASSWORD", + Username: "USERNAME", +} as const; + +/** + * Provisioned Redshift auth type + */ +export type KnowledgeBaseRedshiftProvisionedAuthType = (typeof KnowledgeBaseRedshiftProvisionedAuthType)[keyof typeof KnowledgeBaseRedshiftProvisionedAuthType]; + +export const KnowledgeBaseRedshiftQueryEngineStorageType = { + Redshift: "REDSHIFT", + AwsDataCatalog: "AWS_DATA_CATALOG", +} as const; + +/** + * Redshift query engine storage type + */ +export type KnowledgeBaseRedshiftQueryEngineStorageType = (typeof KnowledgeBaseRedshiftQueryEngineStorageType)[keyof typeof KnowledgeBaseRedshiftQueryEngineStorageType]; + +export const KnowledgeBaseRedshiftQueryEngineType = { + Serverless: "SERVERLESS", + Provisioned: "PROVISIONED", +} as const; + +/** + * Redshift query engine type + */ +export type KnowledgeBaseRedshiftQueryEngineType = (typeof KnowledgeBaseRedshiftQueryEngineType)[keyof typeof KnowledgeBaseRedshiftQueryEngineType]; + +export const KnowledgeBaseRedshiftServerlessAuthType = { + Iam: "IAM", + UsernamePassword: "USERNAME_PASSWORD", +} as const; + +/** + * Serverless Redshift auth type + */ +export type KnowledgeBaseRedshiftServerlessAuthType = (typeof KnowledgeBaseRedshiftServerlessAuthType)[keyof typeof KnowledgeBaseRedshiftServerlessAuthType]; + export const KnowledgeBaseStatus = { Creating: "CREATING", Active: "ACTIVE", @@ -567,6 +628,7 @@ export type KnowledgeBaseSupplementalDataStorageLocationType = (typeof Knowledge export const KnowledgeBaseType = { Vector: "VECTOR", Kendra: "KENDRA", + Sql: "SQL", } as const; /** diff --git a/sdk/nodejs/types/enums/index.ts b/sdk/nodejs/types/enums/index.ts index ab2d3277c2..aeea448768 100644 --- a/sdk/nodejs/types/enums/index.ts +++ b/sdk/nodejs/types/enums/index.ts @@ -469,6 +469,10 @@ export const Region = { * Middle East (Bahrain) */ MeSouth1: "me-south-1", + /** + * Mexico (Central) + */ + MxCentral1: "mx-central-1", /** * South America (Sao Paulo) */ diff --git a/sdk/nodejs/types/input.ts b/sdk/nodejs/types/input.ts index 1157e1982e..fd1ba730fc 100644 --- a/sdk/nodejs/types/input.ts +++ b/sdk/nodejs/types/input.ts @@ -11300,6 +11300,7 @@ export namespace bedrock { * Settings for an Amazon Kendra knowledge base. */ kendraKnowledgeBaseConfiguration?: pulumi.Input; + sqlKnowledgeBaseConfiguration?: pulumi.Input; /** * The type of data that the data source is converted into for the knowledge base. */ @@ -11310,6 +11311,14 @@ export namespace bedrock { vectorKnowledgeBaseConfiguration?: pulumi.Input; } + /** + * Curated query or question and answer pair + */ + export interface KnowledgeBaseCuratedQueryArgs { + naturalLanguage: pulumi.Input; + sql: pulumi.Input; + } + /** * The embeddings model configuration details for the vector model used in Knowledge Base. */ @@ -11454,6 +11463,41 @@ export namespace bedrock { textField: pulumi.Input; } + /** + * Redshift query generation column + */ + export interface KnowledgeBaseQueryGenerationColumnArgs { + description?: pulumi.Input; + inclusion?: pulumi.Input; + name?: pulumi.Input; + } + + /** + * Configurations for generating Redshift engine queries + */ + export interface KnowledgeBaseQueryGenerationConfigurationArgs { + executionTimeoutSeconds?: pulumi.Input; + generationContext?: pulumi.Input; + } + + /** + * Context used to improve query generation + */ + export interface KnowledgeBaseQueryGenerationContextArgs { + curatedQueries?: pulumi.Input[]>; + tables?: pulumi.Input[]>; + } + + /** + * Tables used for Redshift query generation context + */ + export interface KnowledgeBaseQueryGenerationTableArgs { + columns?: pulumi.Input[]>; + description?: pulumi.Input; + inclusion?: pulumi.Input; + name: pulumi.Input; + } + /** * Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS. */ @@ -11502,6 +11546,83 @@ export namespace bedrock { vectorField: pulumi.Input; } + /** + * Configurations for a Redshift knowledge base + */ + export interface KnowledgeBaseRedshiftConfigurationArgs { + queryEngineConfiguration: pulumi.Input; + queryGenerationConfiguration?: pulumi.Input; + storageConfigurations: pulumi.Input[]>; + } + + /** + * Configurations for Redshift query engine provisioned auth setup + */ + export interface KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs { + /** + * Redshift database user + */ + databaseUser?: pulumi.Input; + type: pulumi.Input; + usernamePasswordSecretArn?: pulumi.Input; + } + + /** + * Configurations for provisioned Redshift query engine + */ + export interface KnowledgeBaseRedshiftProvisionedConfigurationArgs { + authConfiguration: pulumi.Input; + clusterIdentifier: pulumi.Input; + } + + /** + * Configurations for Redshift query engine AWS Data Catalog backed storage + */ + export interface KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs { + tableNames: pulumi.Input[]>; + } + + /** + * Configurations for Redshift query engine + */ + export interface KnowledgeBaseRedshiftQueryEngineConfigurationArgs { + provisionedConfiguration?: pulumi.Input; + serverlessConfiguration?: pulumi.Input; + type: pulumi.Input; + } + + /** + * Configurations for Redshift query engine Redshift backed storage + */ + export interface KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs { + databaseName: pulumi.Input; + } + + /** + * Configurations for available Redshift query engine storage types + */ + export interface KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs { + awsDataCatalogConfiguration?: pulumi.Input; + redshiftConfiguration?: pulumi.Input; + type: pulumi.Input; + } + + /** + * Configurations for Redshift query engine serverless auth setup + */ + export interface KnowledgeBaseRedshiftServerlessAuthConfigurationArgs { + type: pulumi.Input; + usernamePasswordSecretArn?: pulumi.Input; + } + + /** + * Configurations for serverless Redshift query engine + */ + export interface KnowledgeBaseRedshiftServerlessConfigurationArgs { + authConfiguration: pulumi.Input; + workgroupArn: pulumi.Input; + } + /** * An Amazon S3 location. */ @@ -11512,6 +11633,14 @@ export namespace bedrock { uri: pulumi.Input; } + /** + * Configurations for a SQL knowledge base + */ + export interface KnowledgeBaseSqlKnowledgeBaseConfigurationArgs { + redshiftConfiguration?: pulumi.Input; + type: pulumi.Input; + } + /** * The vector store service in which the knowledge base is stored. */ @@ -20755,6 +20884,10 @@ export namespace datazone { * Specifies whether to automatically import data quality metrics as part of the data source run. */ autoImportDataQualityResult?: pulumi.Input; + /** + * The catalog name in the AWS Glue run configuration. + */ + catalogName?: pulumi.Input; /** * The data access role included in the configuration details of the AWS Glue data source. */ @@ -20806,11 +20939,11 @@ export namespace datazone { /** * The details of the credentials required to access an Amazon Redshift cluster. */ - redshiftCredentialConfiguration: pulumi.Input; + redshiftCredentialConfiguration?: pulumi.Input; /** * The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. */ - redshiftStorage: pulumi.Input; + redshiftStorage?: pulumi.Input; relationalFilterConfigurations: pulumi.Input[]>; } diff --git a/sdk/nodejs/types/output.ts b/sdk/nodejs/types/output.ts index 61282679fa..c0ba08d8e3 100644 --- a/sdk/nodejs/types/output.ts +++ b/sdk/nodejs/types/output.ts @@ -11744,6 +11744,7 @@ export namespace bedrock { * Settings for an Amazon Kendra knowledge base. */ kendraKnowledgeBaseConfiguration?: outputs.bedrock.KnowledgeBaseKendraKnowledgeBaseConfiguration; + sqlKnowledgeBaseConfiguration?: outputs.bedrock.KnowledgeBaseSqlKnowledgeBaseConfiguration; /** * The type of data that the data source is converted into for the knowledge base. */ @@ -11754,6 +11755,14 @@ export namespace bedrock { vectorKnowledgeBaseConfiguration?: outputs.bedrock.KnowledgeBaseVectorKnowledgeBaseConfiguration; } + /** + * Curated query or question and answer pair + */ + export interface KnowledgeBaseCuratedQuery { + naturalLanguage: string; + sql: string; + } + /** * The embeddings model configuration details for the vector model used in Knowledge Base. */ @@ -11898,6 +11907,41 @@ export namespace bedrock { textField: string; } + /** + * Redshift query generation column + */ + export interface KnowledgeBaseQueryGenerationColumn { + description?: string; + inclusion?: enums.bedrock.KnowledgeBaseInclusionType; + name?: string; + } + + /** + * Configurations for generating Redshift engine queries + */ + export interface KnowledgeBaseQueryGenerationConfiguration { + executionTimeoutSeconds?: number; + generationContext?: outputs.bedrock.KnowledgeBaseQueryGenerationContext; + } + + /** + * Context used to improve query generation + */ + export interface KnowledgeBaseQueryGenerationContext { + curatedQueries?: outputs.bedrock.KnowledgeBaseCuratedQuery[]; + tables?: outputs.bedrock.KnowledgeBaseQueryGenerationTable[]; + } + + /** + * Tables used for Redshift query generation context + */ + export interface KnowledgeBaseQueryGenerationTable { + columns?: outputs.bedrock.KnowledgeBaseQueryGenerationColumn[]; + description?: string; + inclusion?: enums.bedrock.KnowledgeBaseInclusionType; + name: string; + } + /** * Contains details about the storage configuration of the knowledge base in Amazon RDS. For more information, see Create a vector index in Amazon RDS. */ @@ -11946,6 +11990,83 @@ export namespace bedrock { vectorField: string; } + /** + * Configurations for a Redshift knowledge base + */ + export interface KnowledgeBaseRedshiftConfiguration { + queryEngineConfiguration: outputs.bedrock.KnowledgeBaseRedshiftQueryEngineConfiguration; + queryGenerationConfiguration?: outputs.bedrock.KnowledgeBaseQueryGenerationConfiguration; + storageConfigurations: outputs.bedrock.KnowledgeBaseRedshiftQueryEngineStorageConfiguration[]; + } + + /** + * Configurations for Redshift query engine provisioned auth setup + */ + export interface KnowledgeBaseRedshiftProvisionedAuthConfiguration { + /** + * Redshift database user + */ + databaseUser?: string; + type: enums.bedrock.KnowledgeBaseRedshiftProvisionedAuthType; + usernamePasswordSecretArn?: string; + } + + /** + * Configurations for provisioned Redshift query engine + */ + export interface KnowledgeBaseRedshiftProvisionedConfiguration { + authConfiguration: outputs.bedrock.KnowledgeBaseRedshiftProvisionedAuthConfiguration; + clusterIdentifier: string; + } + + /** + * Configurations for Redshift query engine AWS Data Catalog backed storage + */ + export interface KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration { + tableNames: string[]; + } + + /** + * Configurations for Redshift query engine + */ + export interface KnowledgeBaseRedshiftQueryEngineConfiguration { + provisionedConfiguration?: outputs.bedrock.KnowledgeBaseRedshiftProvisionedConfiguration; + serverlessConfiguration?: outputs.bedrock.KnowledgeBaseRedshiftServerlessConfiguration; + type: enums.bedrock.KnowledgeBaseRedshiftQueryEngineType; + } + + /** + * Configurations for Redshift query engine Redshift backed storage + */ + export interface KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration { + databaseName: string; + } + + /** + * Configurations for available Redshift query engine storage types + */ + export interface KnowledgeBaseRedshiftQueryEngineStorageConfiguration { + awsDataCatalogConfiguration?: outputs.bedrock.KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration; + redshiftConfiguration?: outputs.bedrock.KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration; + type: enums.bedrock.KnowledgeBaseRedshiftQueryEngineStorageType; + } + + /** + * Configurations for Redshift query engine serverless auth setup + */ + export interface KnowledgeBaseRedshiftServerlessAuthConfiguration { + type: enums.bedrock.KnowledgeBaseRedshiftServerlessAuthType; + usernamePasswordSecretArn?: string; + } + + /** + * Configurations for serverless Redshift query engine + */ + export interface KnowledgeBaseRedshiftServerlessConfiguration { + authConfiguration: outputs.bedrock.KnowledgeBaseRedshiftServerlessAuthConfiguration; + workgroupArn: string; + } + /** * An Amazon S3 location. */ @@ -11956,6 +12077,14 @@ export namespace bedrock { uri: string; } + /** + * Configurations for a SQL knowledge base + */ + export interface KnowledgeBaseSqlKnowledgeBaseConfiguration { + redshiftConfiguration?: outputs.bedrock.KnowledgeBaseRedshiftConfiguration; + type: enums.bedrock.KnowledgeBaseQueryEngineType; + } + /** * The vector store service in which the knowledge base is stored. */ @@ -21504,6 +21633,10 @@ export namespace datazone { * Specifies whether to automatically import data quality metrics as part of the data source run. */ autoImportDataQualityResult?: boolean; + /** + * The catalog name in the AWS Glue run configuration. + */ + catalogName?: string; /** * The data access role included in the configuration details of the AWS Glue data source. */ @@ -21555,11 +21688,11 @@ export namespace datazone { /** * The details of the credentials required to access an Amazon Redshift cluster. */ - redshiftCredentialConfiguration: outputs.datazone.DataSourceRedshiftCredentialConfiguration; + redshiftCredentialConfiguration?: outputs.datazone.DataSourceRedshiftCredentialConfiguration; /** * The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. */ - redshiftStorage: outputs.datazone.DataSourceRedshiftStorage0Properties | outputs.datazone.DataSourceRedshiftStorage1Properties; + redshiftStorage?: outputs.datazone.DataSourceRedshiftStorage0Properties | outputs.datazone.DataSourceRedshiftStorage1Properties; relationalFilterConfigurations: outputs.datazone.DataSourceRelationalFilterConfiguration[]; } diff --git a/sdk/python/pulumi_aws_native/_enums.py b/sdk/python/pulumi_aws_native/_enums.py index b68fa7c299..3d5dce0cc3 100644 --- a/sdk/python/pulumi_aws_native/_enums.py +++ b/sdk/python/pulumi_aws_native/_enums.py @@ -129,6 +129,10 @@ class Region(str, Enum): """ Middle East (Bahrain) """ + MX_CENTRAL1 = "mx-central-1" + """ + Mexico (Central) + """ SA_EAST1 = "sa-east-1" """ South America (Sao Paulo) diff --git a/sdk/python/pulumi_aws_native/bedrock/_enums.py b/sdk/python/pulumi_aws_native/bedrock/_enums.py index d62a6d682b..851d5f5f8b 100644 --- a/sdk/python/pulumi_aws_native/bedrock/_enums.py +++ b/sdk/python/pulumi_aws_native/bedrock/_enums.py @@ -50,6 +50,12 @@ 'GuardrailSensitiveInformationAction', 'GuardrailStatus', 'GuardrailTopicType', + 'KnowledgeBaseInclusionType', + 'KnowledgeBaseQueryEngineType', + 'KnowledgeBaseRedshiftProvisionedAuthType', + 'KnowledgeBaseRedshiftQueryEngineStorageType', + 'KnowledgeBaseRedshiftQueryEngineType', + 'KnowledgeBaseRedshiftServerlessAuthType', 'KnowledgeBaseStatus', 'KnowledgeBaseStorageType', 'KnowledgeBaseSupplementalDataStorageLocationType', @@ -278,6 +284,7 @@ class DataSourceType(str, Enum): SHAREPOINT = "SHAREPOINT" WEB = "WEB" CUSTOM = "CUSTOM" + REDSHIFT_METADATA = "REDSHIFT_METADATA" class DataSourceWebScopeType(str, Enum): @@ -497,6 +504,54 @@ class GuardrailTopicType(str, Enum): DENY = "DENY" +class KnowledgeBaseInclusionType(str, Enum): + """ + Include or Exclude status for an entity + """ + INCLUDE = "INCLUDE" + EXCLUDE = "EXCLUDE" + + +class KnowledgeBaseQueryEngineType(str, Enum): + """ + SQL query engine type + """ + REDSHIFT = "REDSHIFT" + + +class KnowledgeBaseRedshiftProvisionedAuthType(str, Enum): + """ + Provisioned Redshift auth type + """ + IAM = "IAM" + USERNAME_PASSWORD = "USERNAME_PASSWORD" + USERNAME = "USERNAME" + + +class KnowledgeBaseRedshiftQueryEngineStorageType(str, Enum): + """ + Redshift query engine storage type + """ + REDSHIFT = "REDSHIFT" + AWS_DATA_CATALOG = "AWS_DATA_CATALOG" + + +class KnowledgeBaseRedshiftQueryEngineType(str, Enum): + """ + Redshift query engine type + """ + SERVERLESS = "SERVERLESS" + PROVISIONED = "PROVISIONED" + + +class KnowledgeBaseRedshiftServerlessAuthType(str, Enum): + """ + Serverless Redshift auth type + """ + IAM = "IAM" + USERNAME_PASSWORD = "USERNAME_PASSWORD" + + class KnowledgeBaseStatus(str, Enum): """ The status of a knowledge base. @@ -532,6 +587,7 @@ class KnowledgeBaseType(str, Enum): """ VECTOR = "VECTOR" KENDRA = "KENDRA" + SQL = "SQL" class PromptConversationRole(str, Enum): diff --git a/sdk/python/pulumi_aws_native/bedrock/_inputs.py b/sdk/python/pulumi_aws_native/bedrock/_inputs.py index bac52cb4e6..14a810f30a 100644 --- a/sdk/python/pulumi_aws_native/bedrock/_inputs.py +++ b/sdk/python/pulumi_aws_native/bedrock/_inputs.py @@ -250,6 +250,8 @@ 'KnowledgeBaseBedrockEmbeddingModelConfigurationArgsDict', 'KnowledgeBaseConfigurationArgs', 'KnowledgeBaseConfigurationArgsDict', + 'KnowledgeBaseCuratedQueryArgs', + 'KnowledgeBaseCuratedQueryArgsDict', 'KnowledgeBaseEmbeddingModelConfigurationArgs', 'KnowledgeBaseEmbeddingModelConfigurationArgsDict', 'KnowledgeBaseKendraKnowledgeBaseConfigurationArgs', @@ -266,12 +268,40 @@ 'KnowledgeBasePineconeConfigurationArgsDict', 'KnowledgeBasePineconeFieldMappingArgs', 'KnowledgeBasePineconeFieldMappingArgsDict', + 'KnowledgeBaseQueryGenerationColumnArgs', + 'KnowledgeBaseQueryGenerationColumnArgsDict', + 'KnowledgeBaseQueryGenerationConfigurationArgs', + 'KnowledgeBaseQueryGenerationConfigurationArgsDict', + 'KnowledgeBaseQueryGenerationContextArgs', + 'KnowledgeBaseQueryGenerationContextArgsDict', + 'KnowledgeBaseQueryGenerationTableArgs', + 'KnowledgeBaseQueryGenerationTableArgsDict', 'KnowledgeBaseRdsConfigurationArgs', 'KnowledgeBaseRdsConfigurationArgsDict', 'KnowledgeBaseRdsFieldMappingArgs', 'KnowledgeBaseRdsFieldMappingArgsDict', + 'KnowledgeBaseRedshiftConfigurationArgs', + 'KnowledgeBaseRedshiftConfigurationArgsDict', + 'KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs', + 'KnowledgeBaseRedshiftProvisionedAuthConfigurationArgsDict', + 'KnowledgeBaseRedshiftProvisionedConfigurationArgs', + 'KnowledgeBaseRedshiftProvisionedConfigurationArgsDict', + 'KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs', + 'KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgsDict', + 'KnowledgeBaseRedshiftQueryEngineConfigurationArgs', + 'KnowledgeBaseRedshiftQueryEngineConfigurationArgsDict', + 'KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs', + 'KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgsDict', + 'KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs', + 'KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgsDict', + 'KnowledgeBaseRedshiftServerlessAuthConfigurationArgs', + 'KnowledgeBaseRedshiftServerlessAuthConfigurationArgsDict', + 'KnowledgeBaseRedshiftServerlessConfigurationArgs', + 'KnowledgeBaseRedshiftServerlessConfigurationArgsDict', 'KnowledgeBaseS3LocationArgs', 'KnowledgeBaseS3LocationArgsDict', + 'KnowledgeBaseSqlKnowledgeBaseConfigurationArgs', + 'KnowledgeBaseSqlKnowledgeBaseConfigurationArgsDict', 'KnowledgeBaseStorageConfigurationArgs', 'KnowledgeBaseStorageConfigurationArgsDict', 'KnowledgeBaseSupplementalDataStorageConfigurationArgs', @@ -6679,6 +6709,7 @@ class KnowledgeBaseConfigurationArgsDict(TypedDict): """ Settings for an Amazon Kendra knowledge base. """ + sql_knowledge_base_configuration: NotRequired[pulumi.Input['KnowledgeBaseSqlKnowledgeBaseConfigurationArgsDict']] vector_knowledge_base_configuration: NotRequired[pulumi.Input['KnowledgeBaseVectorKnowledgeBaseConfigurationArgsDict']] """ Contains details about the model that's used to convert the data source into vector embeddings. @@ -6691,6 +6722,7 @@ class KnowledgeBaseConfigurationArgs: def __init__(__self__, *, type: pulumi.Input['KnowledgeBaseType'], kendra_knowledge_base_configuration: Optional[pulumi.Input['KnowledgeBaseKendraKnowledgeBaseConfigurationArgs']] = None, + sql_knowledge_base_configuration: Optional[pulumi.Input['KnowledgeBaseSqlKnowledgeBaseConfigurationArgs']] = None, vector_knowledge_base_configuration: Optional[pulumi.Input['KnowledgeBaseVectorKnowledgeBaseConfigurationArgs']] = None): """ Contains details about the embeddings model used for the knowledge base. @@ -6701,6 +6733,8 @@ def __init__(__self__, *, pulumi.set(__self__, "type", type) if kendra_knowledge_base_configuration is not None: pulumi.set(__self__, "kendra_knowledge_base_configuration", kendra_knowledge_base_configuration) + if sql_knowledge_base_configuration is not None: + pulumi.set(__self__, "sql_knowledge_base_configuration", sql_knowledge_base_configuration) if vector_knowledge_base_configuration is not None: pulumi.set(__self__, "vector_knowledge_base_configuration", vector_knowledge_base_configuration) @@ -6728,6 +6762,15 @@ def kendra_knowledge_base_configuration(self) -> Optional[pulumi.Input['Knowledg def kendra_knowledge_base_configuration(self, value: Optional[pulumi.Input['KnowledgeBaseKendraKnowledgeBaseConfigurationArgs']]): pulumi.set(self, "kendra_knowledge_base_configuration", value) + @property + @pulumi.getter(name="sqlKnowledgeBaseConfiguration") + def sql_knowledge_base_configuration(self) -> Optional[pulumi.Input['KnowledgeBaseSqlKnowledgeBaseConfigurationArgs']]: + return pulumi.get(self, "sql_knowledge_base_configuration") + + @sql_knowledge_base_configuration.setter + def sql_knowledge_base_configuration(self, value: Optional[pulumi.Input['KnowledgeBaseSqlKnowledgeBaseConfigurationArgs']]): + pulumi.set(self, "sql_knowledge_base_configuration", value) + @property @pulumi.getter(name="vectorKnowledgeBaseConfiguration") def vector_knowledge_base_configuration(self) -> Optional[pulumi.Input['KnowledgeBaseVectorKnowledgeBaseConfigurationArgs']]: @@ -6741,6 +6784,46 @@ def vector_knowledge_base_configuration(self, value: Optional[pulumi.Input['Know pulumi.set(self, "vector_knowledge_base_configuration", value) +if not MYPY: + class KnowledgeBaseCuratedQueryArgsDict(TypedDict): + """ + Curated query or question and answer pair + """ + natural_language: pulumi.Input[str] + sql: pulumi.Input[str] +elif False: + KnowledgeBaseCuratedQueryArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseCuratedQueryArgs: + def __init__(__self__, *, + natural_language: pulumi.Input[str], + sql: pulumi.Input[str]): + """ + Curated query or question and answer pair + """ + pulumi.set(__self__, "natural_language", natural_language) + pulumi.set(__self__, "sql", sql) + + @property + @pulumi.getter(name="naturalLanguage") + def natural_language(self) -> pulumi.Input[str]: + return pulumi.get(self, "natural_language") + + @natural_language.setter + def natural_language(self, value: pulumi.Input[str]): + pulumi.set(self, "natural_language", value) + + @property + @pulumi.getter + def sql(self) -> pulumi.Input[str]: + return pulumi.get(self, "sql") + + @sql.setter + def sql(self, value: pulumi.Input[str]): + pulumi.set(self, "sql", value) + + if not MYPY: class KnowledgeBaseEmbeddingModelConfigurationArgsDict(TypedDict): """ @@ -7328,6 +7411,212 @@ def text_field(self, value: pulumi.Input[str]): pulumi.set(self, "text_field", value) +if not MYPY: + class KnowledgeBaseQueryGenerationColumnArgsDict(TypedDict): + """ + Redshift query generation column + """ + description: NotRequired[pulumi.Input[str]] + inclusion: NotRequired[pulumi.Input['KnowledgeBaseInclusionType']] + name: NotRequired[pulumi.Input[str]] +elif False: + KnowledgeBaseQueryGenerationColumnArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseQueryGenerationColumnArgs: + def __init__(__self__, *, + description: Optional[pulumi.Input[str]] = None, + inclusion: Optional[pulumi.Input['KnowledgeBaseInclusionType']] = None, + name: Optional[pulumi.Input[str]] = None): + """ + Redshift query generation column + """ + if description is not None: + pulumi.set(__self__, "description", description) + if inclusion is not None: + pulumi.set(__self__, "inclusion", inclusion) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def inclusion(self) -> Optional[pulumi.Input['KnowledgeBaseInclusionType']]: + return pulumi.get(self, "inclusion") + + @inclusion.setter + def inclusion(self, value: Optional[pulumi.Input['KnowledgeBaseInclusionType']]): + pulumi.set(self, "inclusion", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + +if not MYPY: + class KnowledgeBaseQueryGenerationConfigurationArgsDict(TypedDict): + """ + Configurations for generating Redshift engine queries + """ + execution_timeout_seconds: NotRequired[pulumi.Input[int]] + generation_context: NotRequired[pulumi.Input['KnowledgeBaseQueryGenerationContextArgsDict']] +elif False: + KnowledgeBaseQueryGenerationConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseQueryGenerationConfigurationArgs: + def __init__(__self__, *, + execution_timeout_seconds: Optional[pulumi.Input[int]] = None, + generation_context: Optional[pulumi.Input['KnowledgeBaseQueryGenerationContextArgs']] = None): + """ + Configurations for generating Redshift engine queries + """ + if execution_timeout_seconds is not None: + pulumi.set(__self__, "execution_timeout_seconds", execution_timeout_seconds) + if generation_context is not None: + pulumi.set(__self__, "generation_context", generation_context) + + @property + @pulumi.getter(name="executionTimeoutSeconds") + def execution_timeout_seconds(self) -> Optional[pulumi.Input[int]]: + return pulumi.get(self, "execution_timeout_seconds") + + @execution_timeout_seconds.setter + def execution_timeout_seconds(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "execution_timeout_seconds", value) + + @property + @pulumi.getter(name="generationContext") + def generation_context(self) -> Optional[pulumi.Input['KnowledgeBaseQueryGenerationContextArgs']]: + return pulumi.get(self, "generation_context") + + @generation_context.setter + def generation_context(self, value: Optional[pulumi.Input['KnowledgeBaseQueryGenerationContextArgs']]): + pulumi.set(self, "generation_context", value) + + +if not MYPY: + class KnowledgeBaseQueryGenerationContextArgsDict(TypedDict): + """ + Context used to improve query generation + """ + curated_queries: NotRequired[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseCuratedQueryArgsDict']]]] + tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseQueryGenerationTableArgsDict']]]] +elif False: + KnowledgeBaseQueryGenerationContextArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseQueryGenerationContextArgs: + def __init__(__self__, *, + curated_queries: Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseCuratedQueryArgs']]]] = None, + tables: Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseQueryGenerationTableArgs']]]] = None): + """ + Context used to improve query generation + """ + if curated_queries is not None: + pulumi.set(__self__, "curated_queries", curated_queries) + if tables is not None: + pulumi.set(__self__, "tables", tables) + + @property + @pulumi.getter(name="curatedQueries") + def curated_queries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseCuratedQueryArgs']]]]: + return pulumi.get(self, "curated_queries") + + @curated_queries.setter + def curated_queries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseCuratedQueryArgs']]]]): + pulumi.set(self, "curated_queries", value) + + @property + @pulumi.getter + def tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseQueryGenerationTableArgs']]]]: + return pulumi.get(self, "tables") + + @tables.setter + def tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseQueryGenerationTableArgs']]]]): + pulumi.set(self, "tables", value) + + +if not MYPY: + class KnowledgeBaseQueryGenerationTableArgsDict(TypedDict): + """ + Tables used for Redshift query generation context + """ + name: pulumi.Input[str] + columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseQueryGenerationColumnArgsDict']]]] + description: NotRequired[pulumi.Input[str]] + inclusion: NotRequired[pulumi.Input['KnowledgeBaseInclusionType']] +elif False: + KnowledgeBaseQueryGenerationTableArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseQueryGenerationTableArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + columns: Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseQueryGenerationColumnArgs']]]] = None, + description: Optional[pulumi.Input[str]] = None, + inclusion: Optional[pulumi.Input['KnowledgeBaseInclusionType']] = None): + """ + Tables used for Redshift query generation context + """ + pulumi.set(__self__, "name", name) + if columns is not None: + pulumi.set(__self__, "columns", columns) + if description is not None: + pulumi.set(__self__, "description", description) + if inclusion is not None: + pulumi.set(__self__, "inclusion", inclusion) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseQueryGenerationColumnArgs']]]]: + return pulumi.get(self, "columns") + + @columns.setter + def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseQueryGenerationColumnArgs']]]]): + pulumi.set(self, "columns", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def inclusion(self) -> Optional[pulumi.Input['KnowledgeBaseInclusionType']]: + return pulumi.get(self, "inclusion") + + @inclusion.setter + def inclusion(self, value: Optional[pulumi.Input['KnowledgeBaseInclusionType']]): + pulumi.set(self, "inclusion", value) + + if not MYPY: class KnowledgeBaseRdsConfigurationArgsDict(TypedDict): """ @@ -7531,6 +7820,405 @@ def vector_field(self, value: pulumi.Input[str]): pulumi.set(self, "vector_field", value) +if not MYPY: + class KnowledgeBaseRedshiftConfigurationArgsDict(TypedDict): + """ + Configurations for a Redshift knowledge base + """ + query_engine_configuration: pulumi.Input['KnowledgeBaseRedshiftQueryEngineConfigurationArgsDict'] + storage_configurations: pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgsDict']]] + query_generation_configuration: NotRequired[pulumi.Input['KnowledgeBaseQueryGenerationConfigurationArgsDict']] +elif False: + KnowledgeBaseRedshiftConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftConfigurationArgs: + def __init__(__self__, *, + query_engine_configuration: pulumi.Input['KnowledgeBaseRedshiftQueryEngineConfigurationArgs'], + storage_configurations: pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs']]], + query_generation_configuration: Optional[pulumi.Input['KnowledgeBaseQueryGenerationConfigurationArgs']] = None): + """ + Configurations for a Redshift knowledge base + """ + pulumi.set(__self__, "query_engine_configuration", query_engine_configuration) + pulumi.set(__self__, "storage_configurations", storage_configurations) + if query_generation_configuration is not None: + pulumi.set(__self__, "query_generation_configuration", query_generation_configuration) + + @property + @pulumi.getter(name="queryEngineConfiguration") + def query_engine_configuration(self) -> pulumi.Input['KnowledgeBaseRedshiftQueryEngineConfigurationArgs']: + return pulumi.get(self, "query_engine_configuration") + + @query_engine_configuration.setter + def query_engine_configuration(self, value: pulumi.Input['KnowledgeBaseRedshiftQueryEngineConfigurationArgs']): + pulumi.set(self, "query_engine_configuration", value) + + @property + @pulumi.getter(name="storageConfigurations") + def storage_configurations(self) -> pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs']]]: + return pulumi.get(self, "storage_configurations") + + @storage_configurations.setter + def storage_configurations(self, value: pulumi.Input[Sequence[pulumi.Input['KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs']]]): + pulumi.set(self, "storage_configurations", value) + + @property + @pulumi.getter(name="queryGenerationConfiguration") + def query_generation_configuration(self) -> Optional[pulumi.Input['KnowledgeBaseQueryGenerationConfigurationArgs']]: + return pulumi.get(self, "query_generation_configuration") + + @query_generation_configuration.setter + def query_generation_configuration(self, value: Optional[pulumi.Input['KnowledgeBaseQueryGenerationConfigurationArgs']]): + pulumi.set(self, "query_generation_configuration", value) + + +if not MYPY: + class KnowledgeBaseRedshiftProvisionedAuthConfigurationArgsDict(TypedDict): + """ + Configurations for Redshift query engine provisioned auth setup + """ + type: pulumi.Input['KnowledgeBaseRedshiftProvisionedAuthType'] + database_user: NotRequired[pulumi.Input[str]] + """ + Redshift database user + """ + username_password_secret_arn: NotRequired[pulumi.Input[str]] +elif False: + KnowledgeBaseRedshiftProvisionedAuthConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs: + def __init__(__self__, *, + type: pulumi.Input['KnowledgeBaseRedshiftProvisionedAuthType'], + database_user: Optional[pulumi.Input[str]] = None, + username_password_secret_arn: Optional[pulumi.Input[str]] = None): + """ + Configurations for Redshift query engine provisioned auth setup + :param pulumi.Input[str] database_user: Redshift database user + """ + pulumi.set(__self__, "type", type) + if database_user is not None: + pulumi.set(__self__, "database_user", database_user) + if username_password_secret_arn is not None: + pulumi.set(__self__, "username_password_secret_arn", username_password_secret_arn) + + @property + @pulumi.getter + def type(self) -> pulumi.Input['KnowledgeBaseRedshiftProvisionedAuthType']: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input['KnowledgeBaseRedshiftProvisionedAuthType']): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="databaseUser") + def database_user(self) -> Optional[pulumi.Input[str]]: + """ + Redshift database user + """ + return pulumi.get(self, "database_user") + + @database_user.setter + def database_user(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "database_user", value) + + @property + @pulumi.getter(name="usernamePasswordSecretArn") + def username_password_secret_arn(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "username_password_secret_arn") + + @username_password_secret_arn.setter + def username_password_secret_arn(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "username_password_secret_arn", value) + + +if not MYPY: + class KnowledgeBaseRedshiftProvisionedConfigurationArgsDict(TypedDict): + """ + Configurations for provisioned Redshift query engine + """ + auth_configuration: pulumi.Input['KnowledgeBaseRedshiftProvisionedAuthConfigurationArgsDict'] + cluster_identifier: pulumi.Input[str] +elif False: + KnowledgeBaseRedshiftProvisionedConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftProvisionedConfigurationArgs: + def __init__(__self__, *, + auth_configuration: pulumi.Input['KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs'], + cluster_identifier: pulumi.Input[str]): + """ + Configurations for provisioned Redshift query engine + """ + pulumi.set(__self__, "auth_configuration", auth_configuration) + pulumi.set(__self__, "cluster_identifier", cluster_identifier) + + @property + @pulumi.getter(name="authConfiguration") + def auth_configuration(self) -> pulumi.Input['KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs']: + return pulumi.get(self, "auth_configuration") + + @auth_configuration.setter + def auth_configuration(self, value: pulumi.Input['KnowledgeBaseRedshiftProvisionedAuthConfigurationArgs']): + pulumi.set(self, "auth_configuration", value) + + @property + @pulumi.getter(name="clusterIdentifier") + def cluster_identifier(self) -> pulumi.Input[str]: + return pulumi.get(self, "cluster_identifier") + + @cluster_identifier.setter + def cluster_identifier(self, value: pulumi.Input[str]): + pulumi.set(self, "cluster_identifier", value) + + +if not MYPY: + class KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgsDict(TypedDict): + """ + Configurations for Redshift query engine AWS Data Catalog backed storage + """ + table_names: pulumi.Input[Sequence[pulumi.Input[str]]] +elif False: + KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs: + def __init__(__self__, *, + table_names: pulumi.Input[Sequence[pulumi.Input[str]]]): + """ + Configurations for Redshift query engine AWS Data Catalog backed storage + """ + pulumi.set(__self__, "table_names", table_names) + + @property + @pulumi.getter(name="tableNames") + def table_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]: + return pulumi.get(self, "table_names") + + @table_names.setter + def table_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]): + pulumi.set(self, "table_names", value) + + +if not MYPY: + class KnowledgeBaseRedshiftQueryEngineConfigurationArgsDict(TypedDict): + """ + Configurations for Redshift query engine + """ + type: pulumi.Input['KnowledgeBaseRedshiftQueryEngineType'] + provisioned_configuration: NotRequired[pulumi.Input['KnowledgeBaseRedshiftProvisionedConfigurationArgsDict']] + serverless_configuration: NotRequired[pulumi.Input['KnowledgeBaseRedshiftServerlessConfigurationArgsDict']] +elif False: + KnowledgeBaseRedshiftQueryEngineConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftQueryEngineConfigurationArgs: + def __init__(__self__, *, + type: pulumi.Input['KnowledgeBaseRedshiftQueryEngineType'], + provisioned_configuration: Optional[pulumi.Input['KnowledgeBaseRedshiftProvisionedConfigurationArgs']] = None, + serverless_configuration: Optional[pulumi.Input['KnowledgeBaseRedshiftServerlessConfigurationArgs']] = None): + """ + Configurations for Redshift query engine + """ + pulumi.set(__self__, "type", type) + if provisioned_configuration is not None: + pulumi.set(__self__, "provisioned_configuration", provisioned_configuration) + if serverless_configuration is not None: + pulumi.set(__self__, "serverless_configuration", serverless_configuration) + + @property + @pulumi.getter + def type(self) -> pulumi.Input['KnowledgeBaseRedshiftQueryEngineType']: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input['KnowledgeBaseRedshiftQueryEngineType']): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="provisionedConfiguration") + def provisioned_configuration(self) -> Optional[pulumi.Input['KnowledgeBaseRedshiftProvisionedConfigurationArgs']]: + return pulumi.get(self, "provisioned_configuration") + + @provisioned_configuration.setter + def provisioned_configuration(self, value: Optional[pulumi.Input['KnowledgeBaseRedshiftProvisionedConfigurationArgs']]): + pulumi.set(self, "provisioned_configuration", value) + + @property + @pulumi.getter(name="serverlessConfiguration") + def serverless_configuration(self) -> Optional[pulumi.Input['KnowledgeBaseRedshiftServerlessConfigurationArgs']]: + return pulumi.get(self, "serverless_configuration") + + @serverless_configuration.setter + def serverless_configuration(self, value: Optional[pulumi.Input['KnowledgeBaseRedshiftServerlessConfigurationArgs']]): + pulumi.set(self, "serverless_configuration", value) + + +if not MYPY: + class KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgsDict(TypedDict): + """ + Configurations for Redshift query engine Redshift backed storage + """ + database_name: pulumi.Input[str] +elif False: + KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs: + def __init__(__self__, *, + database_name: pulumi.Input[str]): + """ + Configurations for Redshift query engine Redshift backed storage + """ + pulumi.set(__self__, "database_name", database_name) + + @property + @pulumi.getter(name="databaseName") + def database_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "database_name") + + @database_name.setter + def database_name(self, value: pulumi.Input[str]): + pulumi.set(self, "database_name", value) + + +if not MYPY: + class KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgsDict(TypedDict): + """ + Configurations for available Redshift query engine storage types + """ + type: pulumi.Input['KnowledgeBaseRedshiftQueryEngineStorageType'] + aws_data_catalog_configuration: NotRequired[pulumi.Input['KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgsDict']] + redshift_configuration: NotRequired[pulumi.Input['KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgsDict']] +elif False: + KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftQueryEngineStorageConfigurationArgs: + def __init__(__self__, *, + type: pulumi.Input['KnowledgeBaseRedshiftQueryEngineStorageType'], + aws_data_catalog_configuration: Optional[pulumi.Input['KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs']] = None, + redshift_configuration: Optional[pulumi.Input['KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs']] = None): + """ + Configurations for available Redshift query engine storage types + """ + pulumi.set(__self__, "type", type) + if aws_data_catalog_configuration is not None: + pulumi.set(__self__, "aws_data_catalog_configuration", aws_data_catalog_configuration) + if redshift_configuration is not None: + pulumi.set(__self__, "redshift_configuration", redshift_configuration) + + @property + @pulumi.getter + def type(self) -> pulumi.Input['KnowledgeBaseRedshiftQueryEngineStorageType']: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input['KnowledgeBaseRedshiftQueryEngineStorageType']): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="awsDataCatalogConfiguration") + def aws_data_catalog_configuration(self) -> Optional[pulumi.Input['KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs']]: + return pulumi.get(self, "aws_data_catalog_configuration") + + @aws_data_catalog_configuration.setter + def aws_data_catalog_configuration(self, value: Optional[pulumi.Input['KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfigurationArgs']]): + pulumi.set(self, "aws_data_catalog_configuration", value) + + @property + @pulumi.getter(name="redshiftConfiguration") + def redshift_configuration(self) -> Optional[pulumi.Input['KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs']]: + return pulumi.get(self, "redshift_configuration") + + @redshift_configuration.setter + def redshift_configuration(self, value: Optional[pulumi.Input['KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfigurationArgs']]): + pulumi.set(self, "redshift_configuration", value) + + +if not MYPY: + class KnowledgeBaseRedshiftServerlessAuthConfigurationArgsDict(TypedDict): + """ + Configurations for Redshift query engine serverless auth setup + """ + type: pulumi.Input['KnowledgeBaseRedshiftServerlessAuthType'] + username_password_secret_arn: NotRequired[pulumi.Input[str]] +elif False: + KnowledgeBaseRedshiftServerlessAuthConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftServerlessAuthConfigurationArgs: + def __init__(__self__, *, + type: pulumi.Input['KnowledgeBaseRedshiftServerlessAuthType'], + username_password_secret_arn: Optional[pulumi.Input[str]] = None): + """ + Configurations for Redshift query engine serverless auth setup + """ + pulumi.set(__self__, "type", type) + if username_password_secret_arn is not None: + pulumi.set(__self__, "username_password_secret_arn", username_password_secret_arn) + + @property + @pulumi.getter + def type(self) -> pulumi.Input['KnowledgeBaseRedshiftServerlessAuthType']: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input['KnowledgeBaseRedshiftServerlessAuthType']): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="usernamePasswordSecretArn") + def username_password_secret_arn(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "username_password_secret_arn") + + @username_password_secret_arn.setter + def username_password_secret_arn(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "username_password_secret_arn", value) + + +if not MYPY: + class KnowledgeBaseRedshiftServerlessConfigurationArgsDict(TypedDict): + """ + Configurations for serverless Redshift query engine + """ + auth_configuration: pulumi.Input['KnowledgeBaseRedshiftServerlessAuthConfigurationArgsDict'] + workgroup_arn: pulumi.Input[str] +elif False: + KnowledgeBaseRedshiftServerlessConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseRedshiftServerlessConfigurationArgs: + def __init__(__self__, *, + auth_configuration: pulumi.Input['KnowledgeBaseRedshiftServerlessAuthConfigurationArgs'], + workgroup_arn: pulumi.Input[str]): + """ + Configurations for serverless Redshift query engine + """ + pulumi.set(__self__, "auth_configuration", auth_configuration) + pulumi.set(__self__, "workgroup_arn", workgroup_arn) + + @property + @pulumi.getter(name="authConfiguration") + def auth_configuration(self) -> pulumi.Input['KnowledgeBaseRedshiftServerlessAuthConfigurationArgs']: + return pulumi.get(self, "auth_configuration") + + @auth_configuration.setter + def auth_configuration(self, value: pulumi.Input['KnowledgeBaseRedshiftServerlessAuthConfigurationArgs']): + pulumi.set(self, "auth_configuration", value) + + @property + @pulumi.getter(name="workgroupArn") + def workgroup_arn(self) -> pulumi.Input[str]: + return pulumi.get(self, "workgroup_arn") + + @workgroup_arn.setter + def workgroup_arn(self, value: pulumi.Input[str]): + pulumi.set(self, "workgroup_arn", value) + + if not MYPY: class KnowledgeBaseS3LocationArgsDict(TypedDict): """ @@ -7566,6 +8254,47 @@ def uri(self, value: pulumi.Input[str]): pulumi.set(self, "uri", value) +if not MYPY: + class KnowledgeBaseSqlKnowledgeBaseConfigurationArgsDict(TypedDict): + """ + Configurations for a SQL knowledge base + """ + type: pulumi.Input['KnowledgeBaseQueryEngineType'] + redshift_configuration: NotRequired[pulumi.Input['KnowledgeBaseRedshiftConfigurationArgsDict']] +elif False: + KnowledgeBaseSqlKnowledgeBaseConfigurationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class KnowledgeBaseSqlKnowledgeBaseConfigurationArgs: + def __init__(__self__, *, + type: pulumi.Input['KnowledgeBaseQueryEngineType'], + redshift_configuration: Optional[pulumi.Input['KnowledgeBaseRedshiftConfigurationArgs']] = None): + """ + Configurations for a SQL knowledge base + """ + pulumi.set(__self__, "type", type) + if redshift_configuration is not None: + pulumi.set(__self__, "redshift_configuration", redshift_configuration) + + @property + @pulumi.getter + def type(self) -> pulumi.Input['KnowledgeBaseQueryEngineType']: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input['KnowledgeBaseQueryEngineType']): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="redshiftConfiguration") + def redshift_configuration(self) -> Optional[pulumi.Input['KnowledgeBaseRedshiftConfigurationArgs']]: + return pulumi.get(self, "redshift_configuration") + + @redshift_configuration.setter + def redshift_configuration(self, value: Optional[pulumi.Input['KnowledgeBaseRedshiftConfigurationArgs']]): + pulumi.set(self, "redshift_configuration", value) + + if not MYPY: class KnowledgeBaseStorageConfigurationArgsDict(TypedDict): """ diff --git a/sdk/python/pulumi_aws_native/bedrock/get_knowledge_base.py b/sdk/python/pulumi_aws_native/bedrock/get_knowledge_base.py index 9fa5995a66..6e1893c60c 100644 --- a/sdk/python/pulumi_aws_native/bedrock/get_knowledge_base.py +++ b/sdk/python/pulumi_aws_native/bedrock/get_knowledge_base.py @@ -13,6 +13,7 @@ else: from typing_extensions import NotRequired, TypedDict, TypeAlias from .. import _utilities +from . import outputs from ._enums import * __all__ = [ @@ -24,7 +25,7 @@ @pulumi.output_type class GetKnowledgeBaseResult: - def __init__(__self__, created_at=None, description=None, failure_reasons=None, knowledge_base_arn=None, knowledge_base_id=None, name=None, role_arn=None, status=None, tags=None, updated_at=None): + def __init__(__self__, created_at=None, description=None, failure_reasons=None, knowledge_base_arn=None, knowledge_base_configuration=None, knowledge_base_id=None, name=None, role_arn=None, status=None, tags=None, updated_at=None): if created_at and not isinstance(created_at, str): raise TypeError("Expected argument 'created_at' to be a str") pulumi.set(__self__, "created_at", created_at) @@ -37,6 +38,9 @@ def __init__(__self__, created_at=None, description=None, failure_reasons=None, if knowledge_base_arn and not isinstance(knowledge_base_arn, str): raise TypeError("Expected argument 'knowledge_base_arn' to be a str") pulumi.set(__self__, "knowledge_base_arn", knowledge_base_arn) + if knowledge_base_configuration and not isinstance(knowledge_base_configuration, dict): + raise TypeError("Expected argument 'knowledge_base_configuration' to be a dict") + pulumi.set(__self__, "knowledge_base_configuration", knowledge_base_configuration) if knowledge_base_id and not isinstance(knowledge_base_id, str): raise TypeError("Expected argument 'knowledge_base_id' to be a str") pulumi.set(__self__, "knowledge_base_id", knowledge_base_id) @@ -88,6 +92,14 @@ def knowledge_base_arn(self) -> Optional[str]: """ return pulumi.get(self, "knowledge_base_arn") + @property + @pulumi.getter(name="knowledgeBaseConfiguration") + def knowledge_base_configuration(self) -> Optional['outputs.KnowledgeBaseConfiguration']: + """ + Contains details about the embeddings configuration of the knowledge base. + """ + return pulumi.get(self, "knowledge_base_configuration") + @property @pulumi.getter(name="knowledgeBaseId") def knowledge_base_id(self) -> Optional[str]: @@ -150,6 +162,7 @@ def __await__(self): description=self.description, failure_reasons=self.failure_reasons, knowledge_base_arn=self.knowledge_base_arn, + knowledge_base_configuration=self.knowledge_base_configuration, knowledge_base_id=self.knowledge_base_id, name=self.name, role_arn=self.role_arn, @@ -176,6 +189,7 @@ def get_knowledge_base(knowledge_base_id: Optional[str] = None, description=pulumi.get(__ret__, 'description'), failure_reasons=pulumi.get(__ret__, 'failure_reasons'), knowledge_base_arn=pulumi.get(__ret__, 'knowledge_base_arn'), + knowledge_base_configuration=pulumi.get(__ret__, 'knowledge_base_configuration'), knowledge_base_id=pulumi.get(__ret__, 'knowledge_base_id'), name=pulumi.get(__ret__, 'name'), role_arn=pulumi.get(__ret__, 'role_arn'), @@ -199,6 +213,7 @@ def get_knowledge_base_output(knowledge_base_id: Optional[pulumi.Input[str]] = N description=pulumi.get(__response__, 'description'), failure_reasons=pulumi.get(__response__, 'failure_reasons'), knowledge_base_arn=pulumi.get(__response__, 'knowledge_base_arn'), + knowledge_base_configuration=pulumi.get(__response__, 'knowledge_base_configuration'), knowledge_base_id=pulumi.get(__response__, 'knowledge_base_id'), name=pulumi.get(__response__, 'name'), role_arn=pulumi.get(__response__, 'role_arn'), diff --git a/sdk/python/pulumi_aws_native/bedrock/knowledge_base.py b/sdk/python/pulumi_aws_native/bedrock/knowledge_base.py index cf1c9f77f1..46b738dea5 100644 --- a/sdk/python/pulumi_aws_native/bedrock/knowledge_base.py +++ b/sdk/python/pulumi_aws_native/bedrock/knowledge_base.py @@ -209,7 +209,7 @@ def _internal_init(__self__, __props__.__dict__["knowledge_base_id"] = None __props__.__dict__["status"] = None __props__.__dict__["updated_at"] = None - replace_on_changes = pulumi.ResourceOptions(replace_on_changes=["knowledgeBaseConfiguration", "storageConfiguration"]) + replace_on_changes = pulumi.ResourceOptions(replace_on_changes=["knowledgeBaseConfiguration.kendraKnowledgeBaseConfiguration", "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.redshiftConfiguration.queryEngineConfiguration", "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.redshiftConfiguration.storageConfigurations[*]", "knowledgeBaseConfiguration.sqlKnowledgeBaseConfiguration.type", "knowledgeBaseConfiguration.type", "knowledgeBaseConfiguration.vectorKnowledgeBaseConfiguration", "storageConfiguration"]) opts = pulumi.ResourceOptions.merge(opts, replace_on_changes) super(KnowledgeBase, __self__).__init__( 'aws-native:bedrock:KnowledgeBase', diff --git a/sdk/python/pulumi_aws_native/bedrock/outputs.py b/sdk/python/pulumi_aws_native/bedrock/outputs.py index d9d6daae53..2c5d6e2978 100644 --- a/sdk/python/pulumi_aws_native/bedrock/outputs.py +++ b/sdk/python/pulumi_aws_native/bedrock/outputs.py @@ -185,6 +185,7 @@ 'GuardrailWordPolicyConfig', 'KnowledgeBaseBedrockEmbeddingModelConfiguration', 'KnowledgeBaseConfiguration', + 'KnowledgeBaseCuratedQuery', 'KnowledgeBaseEmbeddingModelConfiguration', 'KnowledgeBaseKendraKnowledgeBaseConfiguration', 'KnowledgeBaseMongoDbAtlasConfiguration', @@ -193,9 +194,23 @@ 'KnowledgeBaseOpenSearchServerlessFieldMapping', 'KnowledgeBasePineconeConfiguration', 'KnowledgeBasePineconeFieldMapping', + 'KnowledgeBaseQueryGenerationColumn', + 'KnowledgeBaseQueryGenerationConfiguration', + 'KnowledgeBaseQueryGenerationContext', + 'KnowledgeBaseQueryGenerationTable', 'KnowledgeBaseRdsConfiguration', 'KnowledgeBaseRdsFieldMapping', + 'KnowledgeBaseRedshiftConfiguration', + 'KnowledgeBaseRedshiftProvisionedAuthConfiguration', + 'KnowledgeBaseRedshiftProvisionedConfiguration', + 'KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration', + 'KnowledgeBaseRedshiftQueryEngineConfiguration', + 'KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration', + 'KnowledgeBaseRedshiftQueryEngineStorageConfiguration', + 'KnowledgeBaseRedshiftServerlessAuthConfiguration', + 'KnowledgeBaseRedshiftServerlessConfiguration', 'KnowledgeBaseS3Location', + 'KnowledgeBaseSqlKnowledgeBaseConfiguration', 'KnowledgeBaseStorageConfiguration', 'KnowledgeBaseSupplementalDataStorageConfiguration', 'KnowledgeBaseSupplementalDataStorageLocation', @@ -7168,6 +7183,8 @@ def __key_warning(key: str): suggest = None if key == "kendraKnowledgeBaseConfiguration": suggest = "kendra_knowledge_base_configuration" + elif key == "sqlKnowledgeBaseConfiguration": + suggest = "sql_knowledge_base_configuration" elif key == "vectorKnowledgeBaseConfiguration": suggest = "vector_knowledge_base_configuration" @@ -7185,6 +7202,7 @@ def get(self, key: str, default = None) -> Any: def __init__(__self__, *, type: 'KnowledgeBaseType', kendra_knowledge_base_configuration: Optional['outputs.KnowledgeBaseKendraKnowledgeBaseConfiguration'] = None, + sql_knowledge_base_configuration: Optional['outputs.KnowledgeBaseSqlKnowledgeBaseConfiguration'] = None, vector_knowledge_base_configuration: Optional['outputs.KnowledgeBaseVectorKnowledgeBaseConfiguration'] = None): """ Contains details about the embeddings model used for the knowledge base. @@ -7195,6 +7213,8 @@ def __init__(__self__, *, pulumi.set(__self__, "type", type) if kendra_knowledge_base_configuration is not None: pulumi.set(__self__, "kendra_knowledge_base_configuration", kendra_knowledge_base_configuration) + if sql_knowledge_base_configuration is not None: + pulumi.set(__self__, "sql_knowledge_base_configuration", sql_knowledge_base_configuration) if vector_knowledge_base_configuration is not None: pulumi.set(__self__, "vector_knowledge_base_configuration", vector_knowledge_base_configuration) @@ -7214,6 +7234,11 @@ def kendra_knowledge_base_configuration(self) -> Optional['outputs.KnowledgeBase """ return pulumi.get(self, "kendra_knowledge_base_configuration") + @property + @pulumi.getter(name="sqlKnowledgeBaseConfiguration") + def sql_knowledge_base_configuration(self) -> Optional['outputs.KnowledgeBaseSqlKnowledgeBaseConfiguration']: + return pulumi.get(self, "sql_knowledge_base_configuration") + @property @pulumi.getter(name="vectorKnowledgeBaseConfiguration") def vector_knowledge_base_configuration(self) -> Optional['outputs.KnowledgeBaseVectorKnowledgeBaseConfiguration']: @@ -7223,6 +7248,48 @@ def vector_knowledge_base_configuration(self) -> Optional['outputs.KnowledgeBase return pulumi.get(self, "vector_knowledge_base_configuration") +@pulumi.output_type +class KnowledgeBaseCuratedQuery(dict): + """ + Curated query or question and answer pair + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "naturalLanguage": + suggest = "natural_language" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseCuratedQuery. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseCuratedQuery.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseCuratedQuery.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + natural_language: str, + sql: str): + """ + Curated query or question and answer pair + """ + pulumi.set(__self__, "natural_language", natural_language) + pulumi.set(__self__, "sql", sql) + + @property + @pulumi.getter(name="naturalLanguage") + def natural_language(self) -> str: + return pulumi.get(self, "natural_language") + + @property + @pulumi.getter + def sql(self) -> str: + return pulumi.get(self, "sql") + + @pulumi.output_type class KnowledgeBaseEmbeddingModelConfiguration(dict): """ @@ -7742,6 +7809,173 @@ def text_field(self) -> str: return pulumi.get(self, "text_field") +@pulumi.output_type +class KnowledgeBaseQueryGenerationColumn(dict): + """ + Redshift query generation column + """ + def __init__(__self__, *, + description: Optional[str] = None, + inclusion: Optional['KnowledgeBaseInclusionType'] = None, + name: Optional[str] = None): + """ + Redshift query generation column + """ + if description is not None: + pulumi.set(__self__, "description", description) + if inclusion is not None: + pulumi.set(__self__, "inclusion", inclusion) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter + def description(self) -> Optional[str]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def inclusion(self) -> Optional['KnowledgeBaseInclusionType']: + return pulumi.get(self, "inclusion") + + @property + @pulumi.getter + def name(self) -> Optional[str]: + return pulumi.get(self, "name") + + +@pulumi.output_type +class KnowledgeBaseQueryGenerationConfiguration(dict): + """ + Configurations for generating Redshift engine queries + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "executionTimeoutSeconds": + suggest = "execution_timeout_seconds" + elif key == "generationContext": + suggest = "generation_context" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseQueryGenerationConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseQueryGenerationConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseQueryGenerationConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + execution_timeout_seconds: Optional[int] = None, + generation_context: Optional['outputs.KnowledgeBaseQueryGenerationContext'] = None): + """ + Configurations for generating Redshift engine queries + """ + if execution_timeout_seconds is not None: + pulumi.set(__self__, "execution_timeout_seconds", execution_timeout_seconds) + if generation_context is not None: + pulumi.set(__self__, "generation_context", generation_context) + + @property + @pulumi.getter(name="executionTimeoutSeconds") + def execution_timeout_seconds(self) -> Optional[int]: + return pulumi.get(self, "execution_timeout_seconds") + + @property + @pulumi.getter(name="generationContext") + def generation_context(self) -> Optional['outputs.KnowledgeBaseQueryGenerationContext']: + return pulumi.get(self, "generation_context") + + +@pulumi.output_type +class KnowledgeBaseQueryGenerationContext(dict): + """ + Context used to improve query generation + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "curatedQueries": + suggest = "curated_queries" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseQueryGenerationContext. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseQueryGenerationContext.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseQueryGenerationContext.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + curated_queries: Optional[Sequence['outputs.KnowledgeBaseCuratedQuery']] = None, + tables: Optional[Sequence['outputs.KnowledgeBaseQueryGenerationTable']] = None): + """ + Context used to improve query generation + """ + if curated_queries is not None: + pulumi.set(__self__, "curated_queries", curated_queries) + if tables is not None: + pulumi.set(__self__, "tables", tables) + + @property + @pulumi.getter(name="curatedQueries") + def curated_queries(self) -> Optional[Sequence['outputs.KnowledgeBaseCuratedQuery']]: + return pulumi.get(self, "curated_queries") + + @property + @pulumi.getter + def tables(self) -> Optional[Sequence['outputs.KnowledgeBaseQueryGenerationTable']]: + return pulumi.get(self, "tables") + + +@pulumi.output_type +class KnowledgeBaseQueryGenerationTable(dict): + """ + Tables used for Redshift query generation context + """ + def __init__(__self__, *, + name: str, + columns: Optional[Sequence['outputs.KnowledgeBaseQueryGenerationColumn']] = None, + description: Optional[str] = None, + inclusion: Optional['KnowledgeBaseInclusionType'] = None): + """ + Tables used for Redshift query generation context + """ + pulumi.set(__self__, "name", name) + if columns is not None: + pulumi.set(__self__, "columns", columns) + if description is not None: + pulumi.set(__self__, "description", description) + if inclusion is not None: + pulumi.set(__self__, "inclusion", inclusion) + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def columns(self) -> Optional[Sequence['outputs.KnowledgeBaseQueryGenerationColumn']]: + return pulumi.get(self, "columns") + + @property + @pulumi.getter + def description(self) -> Optional[str]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def inclusion(self) -> Optional['KnowledgeBaseInclusionType']: + return pulumi.get(self, "inclusion") + + @pulumi.output_type class KnowledgeBaseRdsConfiguration(dict): """ @@ -7911,6 +8145,424 @@ def vector_field(self) -> str: return pulumi.get(self, "vector_field") +@pulumi.output_type +class KnowledgeBaseRedshiftConfiguration(dict): + """ + Configurations for a Redshift knowledge base + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "queryEngineConfiguration": + suggest = "query_engine_configuration" + elif key == "storageConfigurations": + suggest = "storage_configurations" + elif key == "queryGenerationConfiguration": + suggest = "query_generation_configuration" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + query_engine_configuration: 'outputs.KnowledgeBaseRedshiftQueryEngineConfiguration', + storage_configurations: Sequence['outputs.KnowledgeBaseRedshiftQueryEngineStorageConfiguration'], + query_generation_configuration: Optional['outputs.KnowledgeBaseQueryGenerationConfiguration'] = None): + """ + Configurations for a Redshift knowledge base + """ + pulumi.set(__self__, "query_engine_configuration", query_engine_configuration) + pulumi.set(__self__, "storage_configurations", storage_configurations) + if query_generation_configuration is not None: + pulumi.set(__self__, "query_generation_configuration", query_generation_configuration) + + @property + @pulumi.getter(name="queryEngineConfiguration") + def query_engine_configuration(self) -> 'outputs.KnowledgeBaseRedshiftQueryEngineConfiguration': + return pulumi.get(self, "query_engine_configuration") + + @property + @pulumi.getter(name="storageConfigurations") + def storage_configurations(self) -> Sequence['outputs.KnowledgeBaseRedshiftQueryEngineStorageConfiguration']: + return pulumi.get(self, "storage_configurations") + + @property + @pulumi.getter(name="queryGenerationConfiguration") + def query_generation_configuration(self) -> Optional['outputs.KnowledgeBaseQueryGenerationConfiguration']: + return pulumi.get(self, "query_generation_configuration") + + +@pulumi.output_type +class KnowledgeBaseRedshiftProvisionedAuthConfiguration(dict): + """ + Configurations for Redshift query engine provisioned auth setup + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "databaseUser": + suggest = "database_user" + elif key == "usernamePasswordSecretArn": + suggest = "username_password_secret_arn" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftProvisionedAuthConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftProvisionedAuthConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftProvisionedAuthConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + type: 'KnowledgeBaseRedshiftProvisionedAuthType', + database_user: Optional[str] = None, + username_password_secret_arn: Optional[str] = None): + """ + Configurations for Redshift query engine provisioned auth setup + :param str database_user: Redshift database user + """ + pulumi.set(__self__, "type", type) + if database_user is not None: + pulumi.set(__self__, "database_user", database_user) + if username_password_secret_arn is not None: + pulumi.set(__self__, "username_password_secret_arn", username_password_secret_arn) + + @property + @pulumi.getter + def type(self) -> 'KnowledgeBaseRedshiftProvisionedAuthType': + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="databaseUser") + def database_user(self) -> Optional[str]: + """ + Redshift database user + """ + return pulumi.get(self, "database_user") + + @property + @pulumi.getter(name="usernamePasswordSecretArn") + def username_password_secret_arn(self) -> Optional[str]: + return pulumi.get(self, "username_password_secret_arn") + + +@pulumi.output_type +class KnowledgeBaseRedshiftProvisionedConfiguration(dict): + """ + Configurations for provisioned Redshift query engine + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "authConfiguration": + suggest = "auth_configuration" + elif key == "clusterIdentifier": + suggest = "cluster_identifier" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftProvisionedConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftProvisionedConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftProvisionedConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auth_configuration: 'outputs.KnowledgeBaseRedshiftProvisionedAuthConfiguration', + cluster_identifier: str): + """ + Configurations for provisioned Redshift query engine + """ + pulumi.set(__self__, "auth_configuration", auth_configuration) + pulumi.set(__self__, "cluster_identifier", cluster_identifier) + + @property + @pulumi.getter(name="authConfiguration") + def auth_configuration(self) -> 'outputs.KnowledgeBaseRedshiftProvisionedAuthConfiguration': + return pulumi.get(self, "auth_configuration") + + @property + @pulumi.getter(name="clusterIdentifier") + def cluster_identifier(self) -> str: + return pulumi.get(self, "cluster_identifier") + + +@pulumi.output_type +class KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration(dict): + """ + Configurations for Redshift query engine AWS Data Catalog backed storage + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "tableNames": + suggest = "table_names" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + table_names: Sequence[str]): + """ + Configurations for Redshift query engine AWS Data Catalog backed storage + """ + pulumi.set(__self__, "table_names", table_names) + + @property + @pulumi.getter(name="tableNames") + def table_names(self) -> Sequence[str]: + return pulumi.get(self, "table_names") + + +@pulumi.output_type +class KnowledgeBaseRedshiftQueryEngineConfiguration(dict): + """ + Configurations for Redshift query engine + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "provisionedConfiguration": + suggest = "provisioned_configuration" + elif key == "serverlessConfiguration": + suggest = "serverless_configuration" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftQueryEngineConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftQueryEngineConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftQueryEngineConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + type: 'KnowledgeBaseRedshiftQueryEngineType', + provisioned_configuration: Optional['outputs.KnowledgeBaseRedshiftProvisionedConfiguration'] = None, + serverless_configuration: Optional['outputs.KnowledgeBaseRedshiftServerlessConfiguration'] = None): + """ + Configurations for Redshift query engine + """ + pulumi.set(__self__, "type", type) + if provisioned_configuration is not None: + pulumi.set(__self__, "provisioned_configuration", provisioned_configuration) + if serverless_configuration is not None: + pulumi.set(__self__, "serverless_configuration", serverless_configuration) + + @property + @pulumi.getter + def type(self) -> 'KnowledgeBaseRedshiftQueryEngineType': + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="provisionedConfiguration") + def provisioned_configuration(self) -> Optional['outputs.KnowledgeBaseRedshiftProvisionedConfiguration']: + return pulumi.get(self, "provisioned_configuration") + + @property + @pulumi.getter(name="serverlessConfiguration") + def serverless_configuration(self) -> Optional['outputs.KnowledgeBaseRedshiftServerlessConfiguration']: + return pulumi.get(self, "serverless_configuration") + + +@pulumi.output_type +class KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration(dict): + """ + Configurations for Redshift query engine Redshift backed storage + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "databaseName": + suggest = "database_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + database_name: str): + """ + Configurations for Redshift query engine Redshift backed storage + """ + pulumi.set(__self__, "database_name", database_name) + + @property + @pulumi.getter(name="databaseName") + def database_name(self) -> str: + return pulumi.get(self, "database_name") + + +@pulumi.output_type +class KnowledgeBaseRedshiftQueryEngineStorageConfiguration(dict): + """ + Configurations for available Redshift query engine storage types + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "awsDataCatalogConfiguration": + suggest = "aws_data_catalog_configuration" + elif key == "redshiftConfiguration": + suggest = "redshift_configuration" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftQueryEngineStorageConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftQueryEngineStorageConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftQueryEngineStorageConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + type: 'KnowledgeBaseRedshiftQueryEngineStorageType', + aws_data_catalog_configuration: Optional['outputs.KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration'] = None, + redshift_configuration: Optional['outputs.KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration'] = None): + """ + Configurations for available Redshift query engine storage types + """ + pulumi.set(__self__, "type", type) + if aws_data_catalog_configuration is not None: + pulumi.set(__self__, "aws_data_catalog_configuration", aws_data_catalog_configuration) + if redshift_configuration is not None: + pulumi.set(__self__, "redshift_configuration", redshift_configuration) + + @property + @pulumi.getter + def type(self) -> 'KnowledgeBaseRedshiftQueryEngineStorageType': + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="awsDataCatalogConfiguration") + def aws_data_catalog_configuration(self) -> Optional['outputs.KnowledgeBaseRedshiftQueryEngineAwsDataCatalogStorageConfiguration']: + return pulumi.get(self, "aws_data_catalog_configuration") + + @property + @pulumi.getter(name="redshiftConfiguration") + def redshift_configuration(self) -> Optional['outputs.KnowledgeBaseRedshiftQueryEngineRedshiftStorageConfiguration']: + return pulumi.get(self, "redshift_configuration") + + +@pulumi.output_type +class KnowledgeBaseRedshiftServerlessAuthConfiguration(dict): + """ + Configurations for Redshift query engine serverless auth setup + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "usernamePasswordSecretArn": + suggest = "username_password_secret_arn" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftServerlessAuthConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftServerlessAuthConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftServerlessAuthConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + type: 'KnowledgeBaseRedshiftServerlessAuthType', + username_password_secret_arn: Optional[str] = None): + """ + Configurations for Redshift query engine serverless auth setup + """ + pulumi.set(__self__, "type", type) + if username_password_secret_arn is not None: + pulumi.set(__self__, "username_password_secret_arn", username_password_secret_arn) + + @property + @pulumi.getter + def type(self) -> 'KnowledgeBaseRedshiftServerlessAuthType': + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="usernamePasswordSecretArn") + def username_password_secret_arn(self) -> Optional[str]: + return pulumi.get(self, "username_password_secret_arn") + + +@pulumi.output_type +class KnowledgeBaseRedshiftServerlessConfiguration(dict): + """ + Configurations for serverless Redshift query engine + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "authConfiguration": + suggest = "auth_configuration" + elif key == "workgroupArn": + suggest = "workgroup_arn" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseRedshiftServerlessConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseRedshiftServerlessConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseRedshiftServerlessConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auth_configuration: 'outputs.KnowledgeBaseRedshiftServerlessAuthConfiguration', + workgroup_arn: str): + """ + Configurations for serverless Redshift query engine + """ + pulumi.set(__self__, "auth_configuration", auth_configuration) + pulumi.set(__self__, "workgroup_arn", workgroup_arn) + + @property + @pulumi.getter(name="authConfiguration") + def auth_configuration(self) -> 'outputs.KnowledgeBaseRedshiftServerlessAuthConfiguration': + return pulumi.get(self, "auth_configuration") + + @property + @pulumi.getter(name="workgroupArn") + def workgroup_arn(self) -> str: + return pulumi.get(self, "workgroup_arn") + + @pulumi.output_type class KnowledgeBaseS3Location(dict): """ @@ -7933,6 +8585,49 @@ def uri(self) -> str: return pulumi.get(self, "uri") +@pulumi.output_type +class KnowledgeBaseSqlKnowledgeBaseConfiguration(dict): + """ + Configurations for a SQL knowledge base + """ + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "redshiftConfiguration": + suggest = "redshift_configuration" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in KnowledgeBaseSqlKnowledgeBaseConfiguration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + KnowledgeBaseSqlKnowledgeBaseConfiguration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + KnowledgeBaseSqlKnowledgeBaseConfiguration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + type: 'KnowledgeBaseQueryEngineType', + redshift_configuration: Optional['outputs.KnowledgeBaseRedshiftConfiguration'] = None): + """ + Configurations for a SQL knowledge base + """ + pulumi.set(__self__, "type", type) + if redshift_configuration is not None: + pulumi.set(__self__, "redshift_configuration", redshift_configuration) + + @property + @pulumi.getter + def type(self) -> 'KnowledgeBaseQueryEngineType': + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="redshiftConfiguration") + def redshift_configuration(self) -> Optional['outputs.KnowledgeBaseRedshiftConfiguration']: + return pulumi.get(self, "redshift_configuration") + + @pulumi.output_type class KnowledgeBaseStorageConfiguration(dict): """ diff --git a/sdk/python/pulumi_aws_native/datazone/_inputs.py b/sdk/python/pulumi_aws_native/datazone/_inputs.py index f568440863..fe2b74f9bf 100644 --- a/sdk/python/pulumi_aws_native/datazone/_inputs.py +++ b/sdk/python/pulumi_aws_native/datazone/_inputs.py @@ -300,6 +300,10 @@ class DataSourceGlueRunConfigurationInputArgsDict(TypedDict): """ Specifies whether to automatically import data quality metrics as part of the data source run. """ + catalog_name: NotRequired[pulumi.Input[str]] + """ + The catalog name in the AWS Glue run configuration. + """ data_access_role: NotRequired[pulumi.Input[str]] """ The data access role included in the configuration details of the AWS Glue data source. @@ -312,15 +316,19 @@ class DataSourceGlueRunConfigurationInputArgs: def __init__(__self__, *, relational_filter_configurations: pulumi.Input[Sequence[pulumi.Input['DataSourceRelationalFilterConfigurationArgs']]], auto_import_data_quality_result: Optional[pulumi.Input[bool]] = None, + catalog_name: Optional[pulumi.Input[str]] = None, data_access_role: Optional[pulumi.Input[str]] = None): """ :param pulumi.Input[Sequence[pulumi.Input['DataSourceRelationalFilterConfigurationArgs']]] relational_filter_configurations: The relational filter configurations included in the configuration details of the AWS Glue data source. :param pulumi.Input[bool] auto_import_data_quality_result: Specifies whether to automatically import data quality metrics as part of the data source run. + :param pulumi.Input[str] catalog_name: The catalog name in the AWS Glue run configuration. :param pulumi.Input[str] data_access_role: The data access role included in the configuration details of the AWS Glue data source. """ pulumi.set(__self__, "relational_filter_configurations", relational_filter_configurations) if auto_import_data_quality_result is not None: pulumi.set(__self__, "auto_import_data_quality_result", auto_import_data_quality_result) + if catalog_name is not None: + pulumi.set(__self__, "catalog_name", catalog_name) if data_access_role is not None: pulumi.set(__self__, "data_access_role", data_access_role) @@ -348,6 +356,18 @@ def auto_import_data_quality_result(self) -> Optional[pulumi.Input[bool]]: def auto_import_data_quality_result(self, value: Optional[pulumi.Input[bool]]): pulumi.set(self, "auto_import_data_quality_result", value) + @property + @pulumi.getter(name="catalogName") + def catalog_name(self) -> Optional[pulumi.Input[str]]: + """ + The catalog name in the AWS Glue run configuration. + """ + return pulumi.get(self, "catalog_name") + + @catalog_name.setter + def catalog_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "catalog_name", value) + @property @pulumi.getter(name="dataAccessRole") def data_access_role(self) -> Optional[pulumi.Input[str]]: @@ -472,18 +492,18 @@ class DataSourceRedshiftRunConfigurationInputArgsDict(TypedDict): """ The configuration details of the Amazon Redshift data source. """ - redshift_credential_configuration: pulumi.Input['DataSourceRedshiftCredentialConfigurationArgsDict'] + relational_filter_configurations: pulumi.Input[Sequence[pulumi.Input['DataSourceRelationalFilterConfigurationArgsDict']]] + data_access_role: NotRequired[pulumi.Input[str]] """ - The details of the credentials required to access an Amazon Redshift cluster. + The data access role included in the configuration details of the Amazon Redshift data source. """ - redshift_storage: pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgsDict', 'DataSourceRedshiftStorage1PropertiesArgsDict']] + redshift_credential_configuration: NotRequired[pulumi.Input['DataSourceRedshiftCredentialConfigurationArgsDict']] """ - The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. + The details of the credentials required to access an Amazon Redshift cluster. """ - relational_filter_configurations: pulumi.Input[Sequence[pulumi.Input['DataSourceRelationalFilterConfigurationArgsDict']]] - data_access_role: NotRequired[pulumi.Input[str]] + redshift_storage: NotRequired[pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgsDict', 'DataSourceRedshiftStorage1PropertiesArgsDict']]] """ - The data access role included in the configuration details of the Amazon Redshift data source. + The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. """ elif False: DataSourceRedshiftRunConfigurationInputArgsDict: TypeAlias = Mapping[str, Any] @@ -491,45 +511,23 @@ class DataSourceRedshiftRunConfigurationInputArgsDict(TypedDict): @pulumi.input_type class DataSourceRedshiftRunConfigurationInputArgs: def __init__(__self__, *, - redshift_credential_configuration: pulumi.Input['DataSourceRedshiftCredentialConfigurationArgs'], - redshift_storage: pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgs', 'DataSourceRedshiftStorage1PropertiesArgs']], relational_filter_configurations: pulumi.Input[Sequence[pulumi.Input['DataSourceRelationalFilterConfigurationArgs']]], - data_access_role: Optional[pulumi.Input[str]] = None): + data_access_role: Optional[pulumi.Input[str]] = None, + redshift_credential_configuration: Optional[pulumi.Input['DataSourceRedshiftCredentialConfigurationArgs']] = None, + redshift_storage: Optional[pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgs', 'DataSourceRedshiftStorage1PropertiesArgs']]] = None): """ The configuration details of the Amazon Redshift data source. + :param pulumi.Input[str] data_access_role: The data access role included in the configuration details of the Amazon Redshift data source. :param pulumi.Input['DataSourceRedshiftCredentialConfigurationArgs'] redshift_credential_configuration: The details of the credentials required to access an Amazon Redshift cluster. :param pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgs', 'DataSourceRedshiftStorage1PropertiesArgs']] redshift_storage: The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. - :param pulumi.Input[str] data_access_role: The data access role included in the configuration details of the Amazon Redshift data source. """ - pulumi.set(__self__, "redshift_credential_configuration", redshift_credential_configuration) - pulumi.set(__self__, "redshift_storage", redshift_storage) pulumi.set(__self__, "relational_filter_configurations", relational_filter_configurations) if data_access_role is not None: pulumi.set(__self__, "data_access_role", data_access_role) - - @property - @pulumi.getter(name="redshiftCredentialConfiguration") - def redshift_credential_configuration(self) -> pulumi.Input['DataSourceRedshiftCredentialConfigurationArgs']: - """ - The details of the credentials required to access an Amazon Redshift cluster. - """ - return pulumi.get(self, "redshift_credential_configuration") - - @redshift_credential_configuration.setter - def redshift_credential_configuration(self, value: pulumi.Input['DataSourceRedshiftCredentialConfigurationArgs']): - pulumi.set(self, "redshift_credential_configuration", value) - - @property - @pulumi.getter(name="redshiftStorage") - def redshift_storage(self) -> pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgs', 'DataSourceRedshiftStorage1PropertiesArgs']]: - """ - The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. - """ - return pulumi.get(self, "redshift_storage") - - @redshift_storage.setter - def redshift_storage(self, value: pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgs', 'DataSourceRedshiftStorage1PropertiesArgs']]): - pulumi.set(self, "redshift_storage", value) + if redshift_credential_configuration is not None: + pulumi.set(__self__, "redshift_credential_configuration", redshift_credential_configuration) + if redshift_storage is not None: + pulumi.set(__self__, "redshift_storage", redshift_storage) @property @pulumi.getter(name="relationalFilterConfigurations") @@ -552,6 +550,30 @@ def data_access_role(self) -> Optional[pulumi.Input[str]]: def data_access_role(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "data_access_role", value) + @property + @pulumi.getter(name="redshiftCredentialConfiguration") + def redshift_credential_configuration(self) -> Optional[pulumi.Input['DataSourceRedshiftCredentialConfigurationArgs']]: + """ + The details of the credentials required to access an Amazon Redshift cluster. + """ + return pulumi.get(self, "redshift_credential_configuration") + + @redshift_credential_configuration.setter + def redshift_credential_configuration(self, value: Optional[pulumi.Input['DataSourceRedshiftCredentialConfigurationArgs']]): + pulumi.set(self, "redshift_credential_configuration", value) + + @property + @pulumi.getter(name="redshiftStorage") + def redshift_storage(self) -> Optional[pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgs', 'DataSourceRedshiftStorage1PropertiesArgs']]]: + """ + The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. + """ + return pulumi.get(self, "redshift_storage") + + @redshift_storage.setter + def redshift_storage(self, value: Optional[pulumi.Input[Union['DataSourceRedshiftStorage0PropertiesArgs', 'DataSourceRedshiftStorage1PropertiesArgs']]]): + pulumi.set(self, "redshift_storage", value) + if not MYPY: class DataSourceRedshiftServerlessStorageArgsDict(TypedDict): diff --git a/sdk/python/pulumi_aws_native/datazone/data_source.py b/sdk/python/pulumi_aws_native/datazone/data_source.py index 43e122508d..f236264682 100644 --- a/sdk/python/pulumi_aws_native/datazone/data_source.py +++ b/sdk/python/pulumi_aws_native/datazone/data_source.py @@ -23,13 +23,14 @@ class DataSourceArgs: def __init__(__self__, *, domain_identifier: pulumi.Input[str], - environment_identifier: pulumi.Input[str], project_identifier: pulumi.Input[str], type: pulumi.Input[str], asset_forms_input: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceFormInputArgs']]]] = None, configuration: Optional[pulumi.Input[Union['DataSourceConfigurationInput0PropertiesArgs', 'DataSourceConfigurationInput1PropertiesArgs', 'DataSourceConfigurationInput2PropertiesArgs']]] = None, + connection_identifier: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, enable_setting: Optional[pulumi.Input['DataSourceEnableSetting']] = None, + environment_identifier: Optional[pulumi.Input[str]] = None, name: Optional[pulumi.Input[str]] = None, publish_on_import: Optional[pulumi.Input[bool]] = None, recommendation: Optional[pulumi.Input['DataSourceRecommendationConfigurationArgs']] = None, @@ -37,30 +38,34 @@ def __init__(__self__, *, """ The set of arguments for constructing a DataSource resource. :param pulumi.Input[str] domain_identifier: The ID of the Amazon DataZone domain where the data source is created. - :param pulumi.Input[str] environment_identifier: The unique identifier of the Amazon DataZone environment to which the data source publishes assets. :param pulumi.Input[str] project_identifier: The identifier of the Amazon DataZone project in which you want to add the data source. :param pulumi.Input[str] type: The type of the data source. :param pulumi.Input[Sequence[pulumi.Input['DataSourceFormInputArgs']]] asset_forms_input: The metadata forms that are to be attached to the assets that this data source works with. :param pulumi.Input[Union['DataSourceConfigurationInput0PropertiesArgs', 'DataSourceConfigurationInput1PropertiesArgs', 'DataSourceConfigurationInput2PropertiesArgs']] configuration: Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration. + :param pulumi.Input[str] connection_identifier: The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run :param pulumi.Input[str] description: The description of the data source. :param pulumi.Input['DataSourceEnableSetting'] enable_setting: Specifies whether the data source is enabled. + :param pulumi.Input[str] environment_identifier: The unique identifier of the Amazon DataZone environment to which the data source publishes assets. :param pulumi.Input[str] name: The name of the data source. :param pulumi.Input[bool] publish_on_import: Specifies whether the assets that this data source creates in the inventory are to be also automatically published to the catalog. :param pulumi.Input['DataSourceRecommendationConfigurationArgs'] recommendation: Specifies whether the business name generation is to be enabled for this data source. :param pulumi.Input['DataSourceScheduleConfigurationArgs'] schedule: The schedule of the data source runs. """ pulumi.set(__self__, "domain_identifier", domain_identifier) - pulumi.set(__self__, "environment_identifier", environment_identifier) pulumi.set(__self__, "project_identifier", project_identifier) pulumi.set(__self__, "type", type) if asset_forms_input is not None: pulumi.set(__self__, "asset_forms_input", asset_forms_input) if configuration is not None: pulumi.set(__self__, "configuration", configuration) + if connection_identifier is not None: + pulumi.set(__self__, "connection_identifier", connection_identifier) if description is not None: pulumi.set(__self__, "description", description) if enable_setting is not None: pulumi.set(__self__, "enable_setting", enable_setting) + if environment_identifier is not None: + pulumi.set(__self__, "environment_identifier", environment_identifier) if name is not None: pulumi.set(__self__, "name", name) if publish_on_import is not None: @@ -82,18 +87,6 @@ def domain_identifier(self) -> pulumi.Input[str]: def domain_identifier(self, value: pulumi.Input[str]): pulumi.set(self, "domain_identifier", value) - @property - @pulumi.getter(name="environmentIdentifier") - def environment_identifier(self) -> pulumi.Input[str]: - """ - The unique identifier of the Amazon DataZone environment to which the data source publishes assets. - """ - return pulumi.get(self, "environment_identifier") - - @environment_identifier.setter - def environment_identifier(self, value: pulumi.Input[str]): - pulumi.set(self, "environment_identifier", value) - @property @pulumi.getter(name="projectIdentifier") def project_identifier(self) -> pulumi.Input[str]: @@ -142,6 +135,18 @@ def configuration(self) -> Optional[pulumi.Input[Union['DataSourceConfigurationI def configuration(self, value: Optional[pulumi.Input[Union['DataSourceConfigurationInput0PropertiesArgs', 'DataSourceConfigurationInput1PropertiesArgs', 'DataSourceConfigurationInput2PropertiesArgs']]]): pulumi.set(self, "configuration", value) + @property + @pulumi.getter(name="connectionIdentifier") + def connection_identifier(self) -> Optional[pulumi.Input[str]]: + """ + The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + """ + return pulumi.get(self, "connection_identifier") + + @connection_identifier.setter + def connection_identifier(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "connection_identifier", value) + @property @pulumi.getter def description(self) -> Optional[pulumi.Input[str]]: @@ -166,6 +171,18 @@ def enable_setting(self) -> Optional[pulumi.Input['DataSourceEnableSetting']]: def enable_setting(self, value: Optional[pulumi.Input['DataSourceEnableSetting']]): pulumi.set(self, "enable_setting", value) + @property + @pulumi.getter(name="environmentIdentifier") + def environment_identifier(self) -> Optional[pulumi.Input[str]]: + """ + The unique identifier of the Amazon DataZone environment to which the data source publishes assets. + """ + return pulumi.get(self, "environment_identifier") + + @environment_identifier.setter + def environment_identifier(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "environment_identifier", value) + @property @pulumi.getter def name(self) -> Optional[pulumi.Input[str]]: @@ -222,6 +239,7 @@ def __init__(__self__, opts: Optional[pulumi.ResourceOptions] = None, asset_forms_input: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DataSourceFormInputArgs', 'DataSourceFormInputArgsDict']]]]] = None, configuration: Optional[pulumi.Input[Union[Union['DataSourceConfigurationInput0PropertiesArgs', 'DataSourceConfigurationInput0PropertiesArgsDict'], Union['DataSourceConfigurationInput1PropertiesArgs', 'DataSourceConfigurationInput1PropertiesArgsDict'], Union['DataSourceConfigurationInput2PropertiesArgs', 'DataSourceConfigurationInput2PropertiesArgsDict']]]] = None, + connection_identifier: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, domain_identifier: Optional[pulumi.Input[str]] = None, enable_setting: Optional[pulumi.Input['DataSourceEnableSetting']] = None, @@ -240,6 +258,7 @@ def __init__(__self__, :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[Sequence[pulumi.Input[Union['DataSourceFormInputArgs', 'DataSourceFormInputArgsDict']]]] asset_forms_input: The metadata forms that are to be attached to the assets that this data source works with. :param pulumi.Input[Union[Union['DataSourceConfigurationInput0PropertiesArgs', 'DataSourceConfigurationInput0PropertiesArgsDict'], Union['DataSourceConfigurationInput1PropertiesArgs', 'DataSourceConfigurationInput1PropertiesArgsDict'], Union['DataSourceConfigurationInput2PropertiesArgs', 'DataSourceConfigurationInput2PropertiesArgsDict']]] configuration: Configuration of the data source. It can be set to either glueRunConfiguration or redshiftRunConfiguration. + :param pulumi.Input[str] connection_identifier: The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run :param pulumi.Input[str] description: The description of the data source. :param pulumi.Input[str] domain_identifier: The ID of the Amazon DataZone domain where the data source is created. :param pulumi.Input['DataSourceEnableSetting'] enable_setting: Specifies whether the data source is enabled. @@ -277,6 +296,7 @@ def _internal_init(__self__, opts: Optional[pulumi.ResourceOptions] = None, asset_forms_input: Optional[pulumi.Input[Sequence[pulumi.Input[Union['DataSourceFormInputArgs', 'DataSourceFormInputArgsDict']]]]] = None, configuration: Optional[pulumi.Input[Union[Union['DataSourceConfigurationInput0PropertiesArgs', 'DataSourceConfigurationInput0PropertiesArgsDict'], Union['DataSourceConfigurationInput1PropertiesArgs', 'DataSourceConfigurationInput1PropertiesArgsDict'], Union['DataSourceConfigurationInput2PropertiesArgs', 'DataSourceConfigurationInput2PropertiesArgsDict']]]] = None, + connection_identifier: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, domain_identifier: Optional[pulumi.Input[str]] = None, enable_setting: Optional[pulumi.Input['DataSourceEnableSetting']] = None, @@ -298,13 +318,12 @@ def _internal_init(__self__, __props__.__dict__["asset_forms_input"] = asset_forms_input __props__.__dict__["configuration"] = configuration + __props__.__dict__["connection_identifier"] = connection_identifier __props__.__dict__["description"] = description if domain_identifier is None and not opts.urn: raise TypeError("Missing required property 'domain_identifier'") __props__.__dict__["domain_identifier"] = domain_identifier __props__.__dict__["enable_setting"] = enable_setting - if environment_identifier is None and not opts.urn: - raise TypeError("Missing required property 'environment_identifier'") __props__.__dict__["environment_identifier"] = environment_identifier __props__.__dict__["name"] = name if project_identifier is None and not opts.urn: @@ -317,6 +336,7 @@ def _internal_init(__self__, raise TypeError("Missing required property 'type'") __props__.__dict__["type"] = type __props__.__dict__["aws_id"] = None + __props__.__dict__["connection_id"] = None __props__.__dict__["created_at"] = None __props__.__dict__["domain_id"] = None __props__.__dict__["environment_id"] = None @@ -326,7 +346,7 @@ def _internal_init(__self__, __props__.__dict__["project_id"] = None __props__.__dict__["status"] = None __props__.__dict__["updated_at"] = None - replace_on_changes = pulumi.ResourceOptions(replace_on_changes=["domainIdentifier", "environmentIdentifier", "projectIdentifier", "type"]) + replace_on_changes = pulumi.ResourceOptions(replace_on_changes=["connectionIdentifier", "domainIdentifier", "environmentIdentifier", "projectIdentifier", "type"]) opts = pulumi.ResourceOptions.merge(opts, replace_on_changes) super(DataSource, __self__).__init__( 'aws-native:datazone:DataSource', @@ -353,6 +373,8 @@ def get(resource_name: str, __props__.__dict__["asset_forms_input"] = None __props__.__dict__["aws_id"] = None __props__.__dict__["configuration"] = None + __props__.__dict__["connection_id"] = None + __props__.__dict__["connection_identifier"] = None __props__.__dict__["created_at"] = None __props__.__dict__["description"] = None __props__.__dict__["domain_id"] = None @@ -398,6 +420,22 @@ def configuration(self) -> pulumi.Output[Optional[Any]]: """ return pulumi.get(self, "configuration") + @property + @pulumi.getter(name="connectionId") + def connection_id(self) -> pulumi.Output[str]: + """ + The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + """ + return pulumi.get(self, "connection_id") + + @property + @pulumi.getter(name="connectionIdentifier") + def connection_identifier(self) -> pulumi.Output[Optional[str]]: + """ + The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + """ + return pulumi.get(self, "connection_identifier") + @property @pulumi.getter(name="createdAt") def created_at(self) -> pulumi.Output[str]: @@ -448,7 +486,7 @@ def environment_id(self) -> pulumi.Output[str]: @property @pulumi.getter(name="environmentIdentifier") - def environment_identifier(self) -> pulumi.Output[str]: + def environment_identifier(self) -> pulumi.Output[Optional[str]]: """ The unique identifier of the Amazon DataZone environment to which the data source publishes assets. """ diff --git a/sdk/python/pulumi_aws_native/datazone/get_data_source.py b/sdk/python/pulumi_aws_native/datazone/get_data_source.py index 323d68b50f..7db96a6315 100644 --- a/sdk/python/pulumi_aws_native/datazone/get_data_source.py +++ b/sdk/python/pulumi_aws_native/datazone/get_data_source.py @@ -25,7 +25,10 @@ @pulumi.output_type class GetDataSourceResult: - def __init__(__self__, created_at=None, description=None, domain_id=None, enable_setting=None, environment_id=None, id=None, last_run_asset_count=None, last_run_at=None, last_run_status=None, name=None, project_id=None, publish_on_import=None, recommendation=None, schedule=None, status=None, updated_at=None): + def __init__(__self__, connection_id=None, created_at=None, description=None, domain_id=None, enable_setting=None, environment_id=None, id=None, last_run_asset_count=None, last_run_at=None, last_run_status=None, name=None, project_id=None, publish_on_import=None, recommendation=None, schedule=None, status=None, updated_at=None): + if connection_id and not isinstance(connection_id, str): + raise TypeError("Expected argument 'connection_id' to be a str") + pulumi.set(__self__, "connection_id", connection_id) if created_at and not isinstance(created_at, str): raise TypeError("Expected argument 'created_at' to be a str") pulumi.set(__self__, "created_at", created_at) @@ -75,6 +78,14 @@ def __init__(__self__, created_at=None, description=None, domain_id=None, enable raise TypeError("Expected argument 'updated_at' to be a str") pulumi.set(__self__, "updated_at", updated_at) + @property + @pulumi.getter(name="connectionId") + def connection_id(self) -> Optional[str]: + """ + The unique identifier of a connection used to fetch relevant parameters from connection during Datasource run + """ + return pulumi.get(self, "connection_id") + @property @pulumi.getter(name="createdAt") def created_at(self) -> Optional[str]: @@ -210,6 +221,7 @@ def __await__(self): if False: yield self return GetDataSourceResult( + connection_id=self.connection_id, created_at=self.created_at, description=self.description, domain_id=self.domain_id, @@ -245,6 +257,7 @@ def get_data_source(domain_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('aws-native:datazone:getDataSource', __args__, opts=opts, typ=GetDataSourceResult).value return AwaitableGetDataSourceResult( + connection_id=pulumi.get(__ret__, 'connection_id'), created_at=pulumi.get(__ret__, 'created_at'), description=pulumi.get(__ret__, 'description'), domain_id=pulumi.get(__ret__, 'domain_id'), @@ -277,6 +290,7 @@ def get_data_source_output(domain_id: Optional[pulumi.Input[str]] = None, opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) __ret__ = pulumi.runtime.invoke_output('aws-native:datazone:getDataSource', __args__, opts=opts, typ=GetDataSourceResult) return __ret__.apply(lambda __response__: GetDataSourceResult( + connection_id=pulumi.get(__response__, 'connection_id'), created_at=pulumi.get(__response__, 'created_at'), description=pulumi.get(__response__, 'description'), domain_id=pulumi.get(__response__, 'domain_id'), diff --git a/sdk/python/pulumi_aws_native/datazone/outputs.py b/sdk/python/pulumi_aws_native/datazone/outputs.py index 5b6f5c3412..c2bea69d49 100644 --- a/sdk/python/pulumi_aws_native/datazone/outputs.py +++ b/sdk/python/pulumi_aws_native/datazone/outputs.py @@ -268,6 +268,8 @@ def __key_warning(key: str): suggest = "relational_filter_configurations" elif key == "autoImportDataQualityResult": suggest = "auto_import_data_quality_result" + elif key == "catalogName": + suggest = "catalog_name" elif key == "dataAccessRole": suggest = "data_access_role" @@ -285,15 +287,19 @@ def get(self, key: str, default = None) -> Any: def __init__(__self__, *, relational_filter_configurations: Sequence['outputs.DataSourceRelationalFilterConfiguration'], auto_import_data_quality_result: Optional[bool] = None, + catalog_name: Optional[str] = None, data_access_role: Optional[str] = None): """ :param Sequence['DataSourceRelationalFilterConfiguration'] relational_filter_configurations: The relational filter configurations included in the configuration details of the AWS Glue data source. :param bool auto_import_data_quality_result: Specifies whether to automatically import data quality metrics as part of the data source run. + :param str catalog_name: The catalog name in the AWS Glue run configuration. :param str data_access_role: The data access role included in the configuration details of the AWS Glue data source. """ pulumi.set(__self__, "relational_filter_configurations", relational_filter_configurations) if auto_import_data_quality_result is not None: pulumi.set(__self__, "auto_import_data_quality_result", auto_import_data_quality_result) + if catalog_name is not None: + pulumi.set(__self__, "catalog_name", catalog_name) if data_access_role is not None: pulumi.set(__self__, "data_access_role", data_access_role) @@ -313,6 +319,14 @@ def auto_import_data_quality_result(self) -> Optional[bool]: """ return pulumi.get(self, "auto_import_data_quality_result") + @property + @pulumi.getter(name="catalogName") + def catalog_name(self) -> Optional[str]: + """ + The catalog name in the AWS Glue run configuration. + """ + return pulumi.get(self, "catalog_name") + @property @pulumi.getter(name="dataAccessRole") def data_access_role(self) -> Optional[str]: @@ -448,14 +462,14 @@ class DataSourceRedshiftRunConfigurationInput(dict): @staticmethod def __key_warning(key: str): suggest = None - if key == "redshiftCredentialConfiguration": - suggest = "redshift_credential_configuration" - elif key == "redshiftStorage": - suggest = "redshift_storage" - elif key == "relationalFilterConfigurations": + if key == "relationalFilterConfigurations": suggest = "relational_filter_configurations" elif key == "dataAccessRole": suggest = "data_access_role" + elif key == "redshiftCredentialConfiguration": + suggest = "redshift_credential_configuration" + elif key == "redshiftStorage": + suggest = "redshift_storage" if suggest: pulumi.log.warn(f"Key '{key}' not found in DataSourceRedshiftRunConfigurationInput. Access the value via the '{suggest}' property getter instead.") @@ -469,25 +483,40 @@ def get(self, key: str, default = None) -> Any: return super().get(key, default) def __init__(__self__, *, - redshift_credential_configuration: 'outputs.DataSourceRedshiftCredentialConfiguration', - redshift_storage: Any, relational_filter_configurations: Sequence['outputs.DataSourceRelationalFilterConfiguration'], - data_access_role: Optional[str] = None): + data_access_role: Optional[str] = None, + redshift_credential_configuration: Optional['outputs.DataSourceRedshiftCredentialConfiguration'] = None, + redshift_storage: Optional[Any] = None): """ The configuration details of the Amazon Redshift data source. + :param str data_access_role: The data access role included in the configuration details of the Amazon Redshift data source. :param 'DataSourceRedshiftCredentialConfiguration' redshift_credential_configuration: The details of the credentials required to access an Amazon Redshift cluster. :param Union['DataSourceRedshiftStorage0Properties', 'DataSourceRedshiftStorage1Properties'] redshift_storage: The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. - :param str data_access_role: The data access role included in the configuration details of the Amazon Redshift data source. """ - pulumi.set(__self__, "redshift_credential_configuration", redshift_credential_configuration) - pulumi.set(__self__, "redshift_storage", redshift_storage) pulumi.set(__self__, "relational_filter_configurations", relational_filter_configurations) if data_access_role is not None: pulumi.set(__self__, "data_access_role", data_access_role) + if redshift_credential_configuration is not None: + pulumi.set(__self__, "redshift_credential_configuration", redshift_credential_configuration) + if redshift_storage is not None: + pulumi.set(__self__, "redshift_storage", redshift_storage) + + @property + @pulumi.getter(name="relationalFilterConfigurations") + def relational_filter_configurations(self) -> Sequence['outputs.DataSourceRelationalFilterConfiguration']: + return pulumi.get(self, "relational_filter_configurations") + + @property + @pulumi.getter(name="dataAccessRole") + def data_access_role(self) -> Optional[str]: + """ + The data access role included in the configuration details of the Amazon Redshift data source. + """ + return pulumi.get(self, "data_access_role") @property @pulumi.getter(name="redshiftCredentialConfiguration") - def redshift_credential_configuration(self) -> 'outputs.DataSourceRedshiftCredentialConfiguration': + def redshift_credential_configuration(self) -> Optional['outputs.DataSourceRedshiftCredentialConfiguration']: """ The details of the credentials required to access an Amazon Redshift cluster. """ @@ -495,25 +524,12 @@ def redshift_credential_configuration(self) -> 'outputs.DataSourceRedshiftCreden @property @pulumi.getter(name="redshiftStorage") - def redshift_storage(self) -> Any: + def redshift_storage(self) -> Optional[Any]: """ The details of the Amazon Redshift storage as part of the configuration of an Amazon Redshift data source run. """ return pulumi.get(self, "redshift_storage") - @property - @pulumi.getter(name="relationalFilterConfigurations") - def relational_filter_configurations(self) -> Sequence['outputs.DataSourceRelationalFilterConfiguration']: - return pulumi.get(self, "relational_filter_configurations") - - @property - @pulumi.getter(name="dataAccessRole") - def data_access_role(self) -> Optional[str]: - """ - The data access role included in the configuration details of the Amazon Redshift data source. - """ - return pulumi.get(self, "data_access_role") - @pulumi.output_type class DataSourceRedshiftServerlessStorage(dict): diff --git a/sdk/python/pulumi_aws_native/rds/db_instance.py b/sdk/python/pulumi_aws_native/rds/db_instance.py index 47025d5079..692a235414 100644 --- a/sdk/python/pulumi_aws_native/rds/db_instance.py +++ b/sdk/python/pulumi_aws_native/rds/db_instance.py @@ -3331,11 +3331,7 @@ def custom_iam_instance_profile(self) -> pulumi.Output[Optional[str]]: @pulumi.getter(name="databaseInsightsMode") def database_insights_mode(self) -> pulumi.Output[str]: """ - The mode of Database Insights to enable for the DB instance. - - This setting only applies to Amazon Aurora DB instances. - - > Currently, this value is inherited from the DB cluster and can't be changed. + The mode of Database Insights that is enabled for the instance. """ return pulumi.get(self, "database_insights_mode") diff --git a/sdk/python/pulumi_aws_native/rds/get_db_instance.py b/sdk/python/pulumi_aws_native/rds/get_db_instance.py index 58c9c28df9..ea1db28b5a 100644 --- a/sdk/python/pulumi_aws_native/rds/get_db_instance.py +++ b/sdk/python/pulumi_aws_native/rds/get_db_instance.py @@ -334,11 +334,7 @@ def copy_tags_to_snapshot(self) -> Optional[bool]: @pulumi.getter(name="databaseInsightsMode") def database_insights_mode(self) -> Optional[str]: """ - The mode of Database Insights to enable for the DB instance. - - This setting only applies to Amazon Aurora DB instances. - - > Currently, this value is inherited from the DB cluster and can't be changed. + The mode of Database Insights that is enabled for the instance. """ return pulumi.get(self, "database_insights_mode") diff --git a/sdk/python/pulumi_aws_native/sns/get_topic.py b/sdk/python/pulumi_aws_native/sns/get_topic.py index 9cdbed935d..9ddf1d39a3 100644 --- a/sdk/python/pulumi_aws_native/sns/get_topic.py +++ b/sdk/python/pulumi_aws_native/sns/get_topic.py @@ -26,7 +26,7 @@ @pulumi.output_type class GetTopicResult: - def __init__(__self__, archive_policy=None, content_based_deduplication=None, data_protection_policy=None, delivery_status_logging=None, display_name=None, kms_master_key_id=None, signature_version=None, subscription=None, tags=None, topic_arn=None, tracing_config=None): + def __init__(__self__, archive_policy=None, content_based_deduplication=None, data_protection_policy=None, delivery_status_logging=None, display_name=None, fifo_throughput_scope=None, kms_master_key_id=None, signature_version=None, subscription=None, tags=None, topic_arn=None, tracing_config=None): if archive_policy and not isinstance(archive_policy, dict): raise TypeError("Expected argument 'archive_policy' to be a dict") pulumi.set(__self__, "archive_policy", archive_policy) @@ -42,6 +42,9 @@ def __init__(__self__, archive_policy=None, content_based_deduplication=None, da if display_name and not isinstance(display_name, str): raise TypeError("Expected argument 'display_name' to be a str") pulumi.set(__self__, "display_name", display_name) + if fifo_throughput_scope and not isinstance(fifo_throughput_scope, str): + raise TypeError("Expected argument 'fifo_throughput_scope' to be a str") + pulumi.set(__self__, "fifo_throughput_scope", fifo_throughput_scope) if kms_master_key_id and not isinstance(kms_master_key_id, str): raise TypeError("Expected argument 'kms_master_key_id' to be a str") pulumi.set(__self__, "kms_master_key_id", kms_master_key_id) @@ -118,6 +121,11 @@ def display_name(self) -> Optional[str]: """ return pulumi.get(self, "display_name") + @property + @pulumi.getter(name="fifoThroughputScope") + def fifo_throughput_scope(self) -> Optional[str]: + return pulumi.get(self, "fifo_throughput_scope") + @property @pulumi.getter(name="kmsMasterKeyId") def kms_master_key_id(self) -> Optional[str]: @@ -181,6 +189,7 @@ def __await__(self): data_protection_policy=self.data_protection_policy, delivery_status_logging=self.delivery_status_logging, display_name=self.display_name, + fifo_throughput_scope=self.fifo_throughput_scope, kms_master_key_id=self.kms_master_key_id, signature_version=self.signature_version, subscription=self.subscription, @@ -210,6 +219,7 @@ def get_topic(topic_arn: Optional[str] = None, data_protection_policy=pulumi.get(__ret__, 'data_protection_policy'), delivery_status_logging=pulumi.get(__ret__, 'delivery_status_logging'), display_name=pulumi.get(__ret__, 'display_name'), + fifo_throughput_scope=pulumi.get(__ret__, 'fifo_throughput_scope'), kms_master_key_id=pulumi.get(__ret__, 'kms_master_key_id'), signature_version=pulumi.get(__ret__, 'signature_version'), subscription=pulumi.get(__ret__, 'subscription'), @@ -236,6 +246,7 @@ def get_topic_output(topic_arn: Optional[pulumi.Input[str]] = None, data_protection_policy=pulumi.get(__response__, 'data_protection_policy'), delivery_status_logging=pulumi.get(__response__, 'delivery_status_logging'), display_name=pulumi.get(__response__, 'display_name'), + fifo_throughput_scope=pulumi.get(__response__, 'fifo_throughput_scope'), kms_master_key_id=pulumi.get(__response__, 'kms_master_key_id'), signature_version=pulumi.get(__response__, 'signature_version'), subscription=pulumi.get(__response__, 'subscription'), diff --git a/sdk/python/pulumi_aws_native/sns/topic.py b/sdk/python/pulumi_aws_native/sns/topic.py index 8fc1bd7513..82d36571a4 100644 --- a/sdk/python/pulumi_aws_native/sns/topic.py +++ b/sdk/python/pulumi_aws_native/sns/topic.py @@ -29,6 +29,7 @@ def __init__(__self__, *, data_protection_policy: Optional[Any] = None, delivery_status_logging: Optional[pulumi.Input[Sequence[pulumi.Input['TopicLoggingConfigArgs']]]] = None, display_name: Optional[pulumi.Input[str]] = None, + fifo_throughput_scope: Optional[pulumi.Input[str]] = None, fifo_topic: Optional[pulumi.Input[bool]] = None, kms_master_key_id: Optional[pulumi.Input[str]] = None, signature_version: Optional[pulumi.Input[str]] = None, @@ -83,6 +84,8 @@ def __init__(__self__, *, pulumi.set(__self__, "delivery_status_logging", delivery_status_logging) if display_name is not None: pulumi.set(__self__, "display_name", display_name) + if fifo_throughput_scope is not None: + pulumi.set(__self__, "fifo_throughput_scope", fifo_throughput_scope) if fifo_topic is not None: pulumi.set(__self__, "fifo_topic", fifo_topic) if kms_master_key_id is not None: @@ -175,6 +178,15 @@ def display_name(self) -> Optional[pulumi.Input[str]]: def display_name(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "display_name", value) + @property + @pulumi.getter(name="fifoThroughputScope") + def fifo_throughput_scope(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "fifo_throughput_scope") + + @fifo_throughput_scope.setter + def fifo_throughput_scope(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "fifo_throughput_scope", value) + @property @pulumi.getter(name="fifoTopic") def fifo_topic(self) -> Optional[pulumi.Input[bool]]: @@ -275,6 +287,7 @@ def __init__(__self__, data_protection_policy: Optional[Any] = None, delivery_status_logging: Optional[pulumi.Input[Sequence[pulumi.Input[Union['TopicLoggingConfigArgs', 'TopicLoggingConfigArgsDict']]]]] = None, display_name: Optional[pulumi.Input[str]] = None, + fifo_throughput_scope: Optional[pulumi.Input[str]] = None, fifo_topic: Optional[pulumi.Input[bool]] = None, kms_master_key_id: Optional[pulumi.Input[str]] = None, signature_version: Optional[pulumi.Input[str]] = None, @@ -524,6 +537,7 @@ def _internal_init(__self__, data_protection_policy: Optional[Any] = None, delivery_status_logging: Optional[pulumi.Input[Sequence[pulumi.Input[Union['TopicLoggingConfigArgs', 'TopicLoggingConfigArgsDict']]]]] = None, display_name: Optional[pulumi.Input[str]] = None, + fifo_throughput_scope: Optional[pulumi.Input[str]] = None, fifo_topic: Optional[pulumi.Input[bool]] = None, kms_master_key_id: Optional[pulumi.Input[str]] = None, signature_version: Optional[pulumi.Input[str]] = None, @@ -545,6 +559,7 @@ def _internal_init(__self__, __props__.__dict__["data_protection_policy"] = data_protection_policy __props__.__dict__["delivery_status_logging"] = delivery_status_logging __props__.__dict__["display_name"] = display_name + __props__.__dict__["fifo_throughput_scope"] = fifo_throughput_scope __props__.__dict__["fifo_topic"] = fifo_topic __props__.__dict__["kms_master_key_id"] = kms_master_key_id __props__.__dict__["signature_version"] = signature_version @@ -582,6 +597,7 @@ def get(resource_name: str, __props__.__dict__["data_protection_policy"] = None __props__.__dict__["delivery_status_logging"] = None __props__.__dict__["display_name"] = None + __props__.__dict__["fifo_throughput_scope"] = None __props__.__dict__["fifo_topic"] = None __props__.__dict__["kms_master_key_id"] = None __props__.__dict__["signature_version"] = None @@ -649,6 +665,11 @@ def display_name(self) -> pulumi.Output[Optional[str]]: """ return pulumi.get(self, "display_name") + @property + @pulumi.getter(name="fifoThroughputScope") + def fifo_throughput_scope(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "fifo_throughput_scope") + @property @pulumi.getter(name="fifoTopic") def fifo_topic(self) -> pulumi.Output[Optional[bool]]: diff --git a/sdk/python/pulumi_aws_native/ssm/association.py b/sdk/python/pulumi_aws_native/ssm/association.py index e17fdb799c..0d14bca14d 100644 --- a/sdk/python/pulumi_aws_native/ssm/association.py +++ b/sdk/python/pulumi_aws_native/ssm/association.py @@ -43,7 +43,7 @@ def __init__(__self__, *, The set of arguments for constructing a Association resource. :param pulumi.Input[bool] apply_only_at_cron_interval: By default, when you create a new association, the system runs it immediately after it is created and then according to the schedule you specified. Specify this option if you don't want an association to run immediately after you create it. This parameter is not supported for rate expressions. :param pulumi.Input[str] association_name: The name of the association. - :param pulumi.Input[str] automation_target_parameter_name: Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + :param pulumi.Input[str] automation_target_parameter_name: Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . :param pulumi.Input[Sequence[pulumi.Input[str]]] calendar_names: The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see [AWS Systems Manager Change Calendar](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar) . :param pulumi.Input['AssociationComplianceSeverity'] compliance_severity: The severity level that is assigned to the association. :param pulumi.Input[str] document_version: The version of the SSM document to associate with the target. @@ -132,7 +132,7 @@ def association_name(self, value: Optional[pulumi.Input[str]]): @pulumi.getter(name="automationTargetParameterName") def automation_target_parameter_name(self) -> Optional[pulumi.Input[str]]: """ - Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . """ return pulumi.get(self, "automation_target_parameter_name") @@ -451,7 +451,7 @@ def __init__(__self__, :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[bool] apply_only_at_cron_interval: By default, when you create a new association, the system runs it immediately after it is created and then according to the schedule you specified. Specify this option if you don't want an association to run immediately after you create it. This parameter is not supported for rate expressions. :param pulumi.Input[str] association_name: The name of the association. - :param pulumi.Input[str] automation_target_parameter_name: Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + :param pulumi.Input[str] automation_target_parameter_name: Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . :param pulumi.Input[Sequence[pulumi.Input[str]]] calendar_names: The names or Amazon Resource Names (ARNs) of the Change Calendar type documents your associations are gated under. The associations only run when that Change Calendar is open. For more information, see [AWS Systems Manager Change Calendar](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-change-calendar) . :param pulumi.Input['AssociationComplianceSeverity'] compliance_severity: The severity level that is assigned to the association. :param pulumi.Input[str] document_version: The version of the SSM document to associate with the target. @@ -717,7 +717,7 @@ def association_name(self) -> pulumi.Output[Optional[str]]: @pulumi.getter(name="automationTargetParameterName") def automation_target_parameter_name(self) -> pulumi.Output[Optional[str]]: """ - Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . """ return pulumi.get(self, "automation_target_parameter_name") diff --git a/sdk/python/pulumi_aws_native/ssm/get_association.py b/sdk/python/pulumi_aws_native/ssm/get_association.py index 5ee05aadb3..742ac5547b 100644 --- a/sdk/python/pulumi_aws_native/ssm/get_association.py +++ b/sdk/python/pulumi_aws_native/ssm/get_association.py @@ -106,7 +106,7 @@ def association_name(self) -> Optional[str]: @pulumi.getter(name="automationTargetParameterName") def automation_target_parameter_name(self) -> Optional[str]: """ - Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a capability of AWS Systems Manager . + Choose the parameter that will define how your automation will branch out. This target is required for associations that use an Automation runbook and target resources by using rate controls. Automation is a tool in AWS Systems Manager . """ return pulumi.get(self, "automation_target_parameter_name")