oci.oci.DifStack

import * as pulumi from "@pulumi/pulumi";
import * as oci from "@pulumi/oci";

const testStack = new oci.oci.DifStack("test_stack", {
    compartmentId: compartmentId,
    displayName: stackDisplayName,
    services: stackServices,
    stackTemplates: stackStackTemplates,
    adbs: [{
        adminPasswordId: testAdminPassword.id,
        dataStorageSizeInTbs: stackAdbDataStorageSizeInTbs,
        dbVersion: stackAdbDbVersion,
        dbWorkload: stackAdbDbWorkload,
        ecpu: stackAdbEcpu,
        instanceId: stackAdbInstanceId,
        isMtlsConnectionRequired: stackAdbIsMtlsConnectionRequired,
        isPublic: stackAdbIsPublic,
        subnetId: testSubnet.id,
        toolsPublicAccess: stackAdbToolsPublicAccess,
        artifactObjectStoragePath: stackAdbArtifactObjectStoragePath,
        dbCredentials: [{
            userName: stackAdbDbCredentialsUserName,
            secretId: stackAdbDbCredentialsSecretId,
            userType: stackAdbDbCredentialsUserType,
        }],
    }],
    dataflows: [{
        driverShape: stackDataflowDriverShape,
        executorShape: stackDataflowExecutorShape,
        instanceId: stackDataflowInstanceId,
        logBucketInstanceId: stackObjectstorageInstanceId,
        numExecutors: stackDataflowNumExecutors,
        sparkVersion: stackDataflowSparkVersion,
        connections: {
            connectionDetails: {
                difDependencies: [{
                    serviceInstanceId: stackDependencyInstanceId,
                    serviceType: stackDataflowConnectionsConnectionDetailsDifDependenciesServiceType,
                }],
                domainNames: stackDataflowConnectionsConnectionDetailsDomainNames,
            },
            subnetId: testSubnet.id,
        },
        driverShapeConfig: {
            memoryInGbs: stackDataflowDriverShapeConfigMemoryInGbs,
            ocpus: stackDataflowDriverShapeConfigOcpus,
        },
        executorShapeConfig: {
            memoryInGbs: stackDataflowExecutorShapeConfigMemoryInGbs,
            ocpus: stackDataflowExecutorShapeConfigOcpus,
        },
        privateEndpointId: testPrivateEndpoint.id,
        warehouseBucketInstanceId: stackObjectstorageInstanceId,
        execute: stackDataflowExecute,
        archiveUri: stackDataflowArchiveUri,
    }],
    definedTags: {
        "Operations.CostCenter": "42",
    },
    freeformTags: {
        Department: "Finance",
    },
    genais: [{
        baseModel: stackGenaiBaseModel,
        clusterType: stackGenaiClusterType,
        instanceId: stackGenaiInstanceId,
        ociRegion: stackGenaiOciRegion,
        unitCount: stackGenaiUnitCount,
        endpoints: [{
            endpointName: stackGenaiEndpointName,
            isContentModerationEnabled: stackGenaiEndpointsIsContentModerationEnabled,
        }],
    }],
    ggcs: [{
        instanceId: stackGgcsInstanceId,
        ocpu: stackGgcsOcpu,
        passwordSecretId: testSecret.id,
        subnetId: testSubnet.id,
        connections: [{
            connectionName: testConnection.name,
            connectionId: testConnection.id,
            difDependencies: [{
                serviceInstanceId: stackDependencyInstanceId,
                serviceType: stackGgcsConnectionsDifDependenciesServiceType,
            }],
            ggAdminSecretId: testSecret.id,
        }],
        oggVersion: stackGgcsOggVersion,
        publicSubnetId: testSubnet.id,
        artifactObjectStoragePath: stackGgcsArtifactObjectStoragePath,
        users: [{
            userName: stackGgcsUsersUserName,
            secretId: stackGgcsUsersSecretId,
            userType: stackGgcsUsersUserType,
            action: stackGgcsUsersAction,
        }],
        sources: [{
            sourceId: stackGgcsSourcesSourceId,
            action: stackGgcsSourcesAction,
            shouldStartSourceOperations: stackGgcsSourcesShouldStartSourceOperations,
            targetUri: stackGgcsSourcesTargetUri,
            targetConnectionName: stackGgcsSourcesTargetConnectionName,
        }],
        targets: [{
            targetId: stackGgcsTargetId,
            action: stackGgcsAction,
            shouldStartTargetOperations: stackGgcsShouldStartTargetOperations,
            sourceUri: stackGgcsSourceUri,
            sourceConnectionName: stackGgcsSourceConnectionName,
        }],
    }],
    notificationEmail: stackNotificationEmail,
    objectstorages: [{
        instanceId: stackObjectstorageInstanceId,
        objectVersioning: stackObjectstorageObjectVersioning,
        storageTier: stackObjectstorageStorageTier,
        autoTiering: stackObjectstorageAutoTiering,
    }],
    subnetId: stackDeployArtifactsSubnetId,
});

import pulumi
import pulumi_oci as oci

test_stack = oci.oci.DifStack("test_stack",
    compartment_id=compartment_id,
    display_name=stack_display_name,
    services=stack_services,
    stack_templates=stack_stack_templates,
    adbs=[{
        "admin_password_id": test_admin_password["id"],
        "data_storage_size_in_tbs": stack_adb_data_storage_size_in_tbs,
        "db_version": stack_adb_db_version,
        "db_workload": stack_adb_db_workload,
        "ecpu": stack_adb_ecpu,
        "instance_id": stack_adb_instance_id,
        "is_mtls_connection_required": stack_adb_is_mtls_connection_required,
        "is_public": stack_adb_is_public,
        "subnet_id": test_subnet["id"],
        "tools_public_access": stack_adb_tools_public_access,
        "artifact_object_storage_path": stack_adb_artifact_object_storage_path,
        "db_credentials": [{
            "user_name": stack_adb_db_credentials_user_name,
            "secret_id": stack_adb_db_credentials_secret_id,
            "user_type": stack_adb_db_credentials_user_type,
        }],
    }],
    dataflows=[{
        "driver_shape": stack_dataflow_driver_shape,
        "executor_shape": stack_dataflow_executor_shape,
        "instance_id": stack_dataflow_instance_id,
        "log_bucket_instance_id": stack_objectstorage_instance_id,
        "num_executors": stack_dataflow_num_executors,
        "spark_version": stack_dataflow_spark_version,
        "connections": {
            "connection_details": {
                "dif_dependencies": [{
                    "service_instance_id": stack_dependency_instance_id,
                    "service_type": stack_dataflow_connections_connection_details_dif_dependencies_service_type,
                }],
                "domain_names": stack_dataflow_connections_connection_details_domain_names,
            },
            "subnet_id": test_subnet["id"],
        },
        "driver_shape_config": {
            "memory_in_gbs": stack_dataflow_driver_shape_config_memory_in_gbs,
            "ocpus": stack_dataflow_driver_shape_config_ocpus,
        },
        "executor_shape_config": {
            "memory_in_gbs": stack_dataflow_executor_shape_config_memory_in_gbs,
            "ocpus": stack_dataflow_executor_shape_config_ocpus,
        },
        "private_endpoint_id": test_private_endpoint["id"],
        "warehouse_bucket_instance_id": stack_objectstorage_instance_id,
        "execute": stack_dataflow_execute,
        "archive_uri": stack_dataflow_archive_uri,
    }],
    defined_tags={
        "Operations.CostCenter": "42",
    },
    freeform_tags={
        "Department": "Finance",
    },
    genais=[{
        "base_model": stack_genai_base_model,
        "cluster_type": stack_genai_cluster_type,
        "instance_id": stack_genai_instance_id,
        "oci_region": stack_genai_oci_region,
        "unit_count": stack_genai_unit_count,
        "endpoints": [{
            "endpoint_name": stack_genai_endpoint_name,
            "is_content_moderation_enabled": stack_genai_endpoints_is_content_moderation_enabled,
        }],
    }],
    ggcs=[{
        "instance_id": stack_ggcs_instance_id,
        "ocpu": stack_ggcs_ocpu,
        "password_secret_id": test_secret["id"],
        "subnet_id": test_subnet["id"],
        "connections": [{
            "connection_name": test_connection["name"],
            "connection_id": test_connection["id"],
            "dif_dependencies": [{
                "service_instance_id": stack_dependency_instance_id,
                "service_type": stack_ggcs_connections_dif_dependencies_service_type,
            }],
            "gg_admin_secret_id": test_secret["id"],
        }],
        "ogg_version": stack_ggcs_ogg_version,
        "public_subnet_id": test_subnet["id"],
        "artifact_object_storage_path": stack_ggcs_artifact_object_storage_path,
        "users": [{
            "user_name": stack_ggcs_users_user_name,
            "secret_id": stack_ggcs_users_secret_id,
            "user_type": stack_ggcs_users_user_type,
            "action": stack_ggcs_users_action,
        }],
        "sources": [{
            "source_id": stack_ggcs_sources_source_id,
            "action": stack_ggcs_sources_action,
            "should_start_source_operations": stack_ggcs_sources_should_start_source_operations,
            "target_uri": stack_ggcs_sources_target_uri,
            "target_connection_name": stack_ggcs_sources_target_connection_name,
        }],
        "targets": [{
            "target_id": stack_ggcs_target_id,
            "action": stack_ggcs_action,
            "should_start_target_operations": stack_ggcs_should_start_target_operations,
            "source_uri": stack_ggcs_source_uri,
            "source_connection_name": stack_ggcs_source_connection_name,
        }],
    }],
    notification_email=stack_notification_email,
    objectstorages=[{
        "instance_id": stack_objectstorage_instance_id,
        "object_versioning": stack_objectstorage_object_versioning,
        "storage_tier": stack_objectstorage_storage_tier,
        "auto_tiering": stack_objectstorage_auto_tiering,
    }],
    subnet_id=stack_deploy_artifacts_subnet_id)

package main

import (
	"github.com/pulumi/pulumi-oci/sdk/v3/go/oci/oci"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := oci.NewDifStack(ctx, "test_stack", &oci.DifStackArgs{
			CompartmentId:  pulumi.Any(compartmentId),
			DisplayName:    pulumi.Any(stackDisplayName),
			Services:       pulumi.Any(stackServices),
			StackTemplates: pulumi.Any(stackStackTemplates),
			Adbs: oci.DifStackAdbArray{
				&oci.DifStackAdbArgs{
					AdminPasswordId:           pulumi.Any(testAdminPassword.Id),
					DataStorageSizeInTbs:      pulumi.Any(stackAdbDataStorageSizeInTbs),
					DbVersion:                 pulumi.Any(stackAdbDbVersion),
					DbWorkload:                pulumi.Any(stackAdbDbWorkload),
					Ecpu:                      pulumi.Any(stackAdbEcpu),
					InstanceId:                pulumi.Any(stackAdbInstanceId),
					IsMtlsConnectionRequired:  pulumi.Any(stackAdbIsMtlsConnectionRequired),
					IsPublic:                  pulumi.Any(stackAdbIsPublic),
					SubnetId:                  pulumi.Any(testSubnet.Id),
					ToolsPublicAccess:         pulumi.Any(stackAdbToolsPublicAccess),
					ArtifactObjectStoragePath: pulumi.Any(stackAdbArtifactObjectStoragePath),
					DbCredentials: oci.DifStackAdbDbCredentialArray{
						&oci.DifStackAdbDbCredentialArgs{
							UserName: pulumi.Any(stackAdbDbCredentialsUserName),
							SecretId: pulumi.Any(stackAdbDbCredentialsSecretId),
							UserType: pulumi.Any(stackAdbDbCredentialsUserType),
						},
					},
				},
			},
			Dataflows: oci.DifStackDataflowArray{
				&oci.DifStackDataflowArgs{
					DriverShape:         pulumi.Any(stackDataflowDriverShape),
					ExecutorShape:       pulumi.Any(stackDataflowExecutorShape),
					InstanceId:          pulumi.Any(stackDataflowInstanceId),
					LogBucketInstanceId: pulumi.Any(stackObjectstorageInstanceId),
					NumExecutors:        pulumi.Any(stackDataflowNumExecutors),
					SparkVersion:        pulumi.Any(stackDataflowSparkVersion),
					Connections: &oci.DifStackDataflowConnectionsArgs{
						ConnectionDetails: &oci.DifStackDataflowConnectionsConnectionDetailsArgs{
							DifDependencies: oci.DifStackDataflowConnectionsConnectionDetailsDifDependencyArray{
								&oci.DifStackDataflowConnectionsConnectionDetailsDifDependencyArgs{
									ServiceInstanceId: pulumi.Any(stackDependencyInstanceId),
									ServiceType:       pulumi.Any(stackDataflowConnectionsConnectionDetailsDifDependenciesServiceType),
								},
							},
							DomainNames: pulumi.Any(stackDataflowConnectionsConnectionDetailsDomainNames),
						},
						SubnetId: pulumi.Any(testSubnet.Id),
					},
					DriverShapeConfig: &oci.DifStackDataflowDriverShapeConfigArgs{
						MemoryInGbs: pulumi.Any(stackDataflowDriverShapeConfigMemoryInGbs),
						Ocpus:       pulumi.Any(stackDataflowDriverShapeConfigOcpus),
					},
					ExecutorShapeConfig: &oci.DifStackDataflowExecutorShapeConfigArgs{
						MemoryInGbs: pulumi.Any(stackDataflowExecutorShapeConfigMemoryInGbs),
						Ocpus:       pulumi.Any(stackDataflowExecutorShapeConfigOcpus),
					},
					PrivateEndpointId:         pulumi.Any(testPrivateEndpoint.Id),
					WarehouseBucketInstanceId: pulumi.Any(stackObjectstorageInstanceId),
					Execute:                   pulumi.Any(stackDataflowExecute),
					ArchiveUri:                pulumi.Any(stackDataflowArchiveUri),
				},
			},
			DefinedTags: pulumi.StringMap{
				"Operations.CostCenter": pulumi.String("42"),
			},
			FreeformTags: pulumi.StringMap{
				"Department": pulumi.String("Finance"),
			},
			Genais: oci.DifStackGenaiArray{
				&oci.DifStackGenaiArgs{
					BaseModel:   pulumi.Any(stackGenaiBaseModel),
					ClusterType: pulumi.Any(stackGenaiClusterType),
					InstanceId:  pulumi.Any(stackGenaiInstanceId),
					OciRegion:   pulumi.Any(stackGenaiOciRegion),
					UnitCount:   pulumi.Any(stackGenaiUnitCount),
					Endpoints: oci.DifStackGenaiEndpointArray{
						&oci.DifStackGenaiEndpointArgs{
							EndpointName:               pulumi.Any(stackGenaiEndpointName),
							IsContentModerationEnabled: pulumi.Any(stackGenaiEndpointsIsContentModerationEnabled),
						},
					},
				},
			},
			Ggcs: oci.DifStackGgcArray{
				&oci.DifStackGgcArgs{
					InstanceId:       pulumi.Any(stackGgcsInstanceId),
					Ocpu:             pulumi.Any(stackGgcsOcpu),
					PasswordSecretId: pulumi.Any(testSecret.Id),
					SubnetId:         pulumi.Any(testSubnet.Id),
					Connections: oci.DifStackGgcConnectionArray{
						&oci.DifStackGgcConnectionArgs{
							ConnectionName: pulumi.Any(testConnection.Name),
							ConnectionId:   pulumi.Any(testConnection.Id),
							DifDependencies: oci.DifStackGgcConnectionDifDependencyArray{
								&oci.DifStackGgcConnectionDifDependencyArgs{
									ServiceInstanceId: pulumi.Any(stackDependencyInstanceId),
									ServiceType:       pulumi.Any(stackGgcsConnectionsDifDependenciesServiceType),
								},
							},
							GgAdminSecretId: pulumi.Any(testSecret.Id),
						},
					},
					OggVersion:                pulumi.Any(stackGgcsOggVersion),
					PublicSubnetId:            pulumi.Any(testSubnet.Id),
					ArtifactObjectStoragePath: pulumi.Any(stackGgcsArtifactObjectStoragePath),
					Users: oci.DifStackGgcUserArray{
						&oci.DifStackGgcUserArgs{
							UserName: pulumi.Any(stackGgcsUsersUserName),
							SecretId: pulumi.Any(stackGgcsUsersSecretId),
							UserType: pulumi.Any(stackGgcsUsersUserType),
							Action:   pulumi.Any(stackGgcsUsersAction),
						},
					},
					Sources: oci.DifStackGgcSourceArray{
						&oci.DifStackGgcSourceArgs{
							SourceId:                    pulumi.Any(stackGgcsSourcesSourceId),
							Action:                      pulumi.Any(stackGgcsSourcesAction),
							ShouldStartSourceOperations: pulumi.Any(stackGgcsSourcesShouldStartSourceOperations),
							TargetUri:                   pulumi.Any(stackGgcsSourcesTargetUri),
							TargetConnectionName:        pulumi.Any(stackGgcsSourcesTargetConnectionName),
						},
					},
					Targets: oci.DifStackGgcTargetArray{
						&oci.DifStackGgcTargetArgs{
							TargetId:                    pulumi.Any(stackGgcsTargetId),
							Action:                      pulumi.Any(stackGgcsAction),
							ShouldStartTargetOperations: pulumi.Any(stackGgcsShouldStartTargetOperations),
							SourceUri:                   pulumi.Any(stackGgcsSourceUri),
							SourceConnectionName:        pulumi.Any(stackGgcsSourceConnectionName),
						},
					},
				},
			},
			NotificationEmail: pulumi.Any(stackNotificationEmail),
			Objectstorages: oci.DifStackObjectstorageArray{
				&oci.DifStackObjectstorageArgs{
					InstanceId:       pulumi.Any(stackObjectstorageInstanceId),
					ObjectVersioning: pulumi.Any(stackObjectstorageObjectVersioning),
					StorageTier:      pulumi.Any(stackObjectstorageStorageTier),
					AutoTiering:      pulumi.Any(stackObjectstorageAutoTiering),
				},
			},
			SubnetId: pulumi.Any(stackDeployArtifactsSubnetId),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Oci = Pulumi.Oci;

return await Deployment.RunAsync(() => 
{
    var testStack = new Oci.Oci.DifStack("test_stack", new()
    {
        CompartmentId = compartmentId,
        DisplayName = stackDisplayName,
        Services = stackServices,
        StackTemplates = stackStackTemplates,
        Adbs = new[]
        {
            new Oci.Oci.Inputs.DifStackAdbArgs
            {
                AdminPasswordId = testAdminPassword.Id,
                DataStorageSizeInTbs = stackAdbDataStorageSizeInTbs,
                DbVersion = stackAdbDbVersion,
                DbWorkload = stackAdbDbWorkload,
                Ecpu = stackAdbEcpu,
                InstanceId = stackAdbInstanceId,
                IsMtlsConnectionRequired = stackAdbIsMtlsConnectionRequired,
                IsPublic = stackAdbIsPublic,
                SubnetId = testSubnet.Id,
                ToolsPublicAccess = stackAdbToolsPublicAccess,
                ArtifactObjectStoragePath = stackAdbArtifactObjectStoragePath,
                DbCredentials = new[]
                {
                    new Oci.Oci.Inputs.DifStackAdbDbCredentialArgs
                    {
                        UserName = stackAdbDbCredentialsUserName,
                        SecretId = stackAdbDbCredentialsSecretId,
                        UserType = stackAdbDbCredentialsUserType,
                    },
                },
            },
        },
        Dataflows = new[]
        {
            new Oci.Oci.Inputs.DifStackDataflowArgs
            {
                DriverShape = stackDataflowDriverShape,
                ExecutorShape = stackDataflowExecutorShape,
                InstanceId = stackDataflowInstanceId,
                LogBucketInstanceId = stackObjectstorageInstanceId,
                NumExecutors = stackDataflowNumExecutors,
                SparkVersion = stackDataflowSparkVersion,
                Connections = new Oci.Oci.Inputs.DifStackDataflowConnectionsArgs
                {
                    ConnectionDetails = new Oci.Oci.Inputs.DifStackDataflowConnectionsConnectionDetailsArgs
                    {
                        DifDependencies = new[]
                        {
                            new Oci.Oci.Inputs.DifStackDataflowConnectionsConnectionDetailsDifDependencyArgs
                            {
                                ServiceInstanceId = stackDependencyInstanceId,
                                ServiceType = stackDataflowConnectionsConnectionDetailsDifDependenciesServiceType,
                            },
                        },
                        DomainNames = stackDataflowConnectionsConnectionDetailsDomainNames,
                    },
                    SubnetId = testSubnet.Id,
                },
                DriverShapeConfig = new Oci.Oci.Inputs.DifStackDataflowDriverShapeConfigArgs
                {
                    MemoryInGbs = stackDataflowDriverShapeConfigMemoryInGbs,
                    Ocpus = stackDataflowDriverShapeConfigOcpus,
                },
                ExecutorShapeConfig = new Oci.Oci.Inputs.DifStackDataflowExecutorShapeConfigArgs
                {
                    MemoryInGbs = stackDataflowExecutorShapeConfigMemoryInGbs,
                    Ocpus = stackDataflowExecutorShapeConfigOcpus,
                },
                PrivateEndpointId = testPrivateEndpoint.Id,
                WarehouseBucketInstanceId = stackObjectstorageInstanceId,
                Execute = stackDataflowExecute,
                ArchiveUri = stackDataflowArchiveUri,
            },
        },
        DefinedTags = 
        {
            { "Operations.CostCenter", "42" },
        },
        FreeformTags = 
        {
            { "Department", "Finance" },
        },
        Genais = new[]
        {
            new Oci.Oci.Inputs.DifStackGenaiArgs
            {
                BaseModel = stackGenaiBaseModel,
                ClusterType = stackGenaiClusterType,
                InstanceId = stackGenaiInstanceId,
                OciRegion = stackGenaiOciRegion,
                UnitCount = stackGenaiUnitCount,
                Endpoints = new[]
                {
                    new Oci.Oci.Inputs.DifStackGenaiEndpointArgs
                    {
                        EndpointName = stackGenaiEndpointName,
                        IsContentModerationEnabled = stackGenaiEndpointsIsContentModerationEnabled,
                    },
                },
            },
        },
        Ggcs = new[]
        {
            new Oci.Oci.Inputs.DifStackGgcArgs
            {
                InstanceId = stackGgcsInstanceId,
                Ocpu = stackGgcsOcpu,
                PasswordSecretId = testSecret.Id,
                SubnetId = testSubnet.Id,
                Connections = new[]
                {
                    new Oci.Oci.Inputs.DifStackGgcConnectionArgs
                    {
                        ConnectionName = testConnection.Name,
                        ConnectionId = testConnection.Id,
                        DifDependencies = new[]
                        {
                            new Oci.Oci.Inputs.DifStackGgcConnectionDifDependencyArgs
                            {
                                ServiceInstanceId = stackDependencyInstanceId,
                                ServiceType = stackGgcsConnectionsDifDependenciesServiceType,
                            },
                        },
                        GgAdminSecretId = testSecret.Id,
                    },
                },
                OggVersion = stackGgcsOggVersion,
                PublicSubnetId = testSubnet.Id,
                ArtifactObjectStoragePath = stackGgcsArtifactObjectStoragePath,
                Users = new[]
                {
                    new Oci.Oci.Inputs.DifStackGgcUserArgs
                    {
                        UserName = stackGgcsUsersUserName,
                        SecretId = stackGgcsUsersSecretId,
                        UserType = stackGgcsUsersUserType,
                        Action = stackGgcsUsersAction,
                    },
                },
                Sources = new[]
                {
                    new Oci.Oci.Inputs.DifStackGgcSourceArgs
                    {
                        SourceId = stackGgcsSourcesSourceId,
                        Action = stackGgcsSourcesAction,
                        ShouldStartSourceOperations = stackGgcsSourcesShouldStartSourceOperations,
                        TargetUri = stackGgcsSourcesTargetUri,
                        TargetConnectionName = stackGgcsSourcesTargetConnectionName,
                    },
                },
                Targets = new[]
                {
                    new Oci.Oci.Inputs.DifStackGgcTargetArgs
                    {
                        TargetId = stackGgcsTargetId,
                        Action = stackGgcsAction,
                        ShouldStartTargetOperations = stackGgcsShouldStartTargetOperations,
                        SourceUri = stackGgcsSourceUri,
                        SourceConnectionName = stackGgcsSourceConnectionName,
                    },
                },
            },
        },
        NotificationEmail = stackNotificationEmail,
        Objectstorages = new[]
        {
            new Oci.Oci.Inputs.DifStackObjectstorageArgs
            {
                InstanceId = stackObjectstorageInstanceId,
                ObjectVersioning = stackObjectstorageObjectVersioning,
                StorageTier = stackObjectstorageStorageTier,
                AutoTiering = stackObjectstorageAutoTiering,
            },
        },
        SubnetId = stackDeployArtifactsSubnetId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.oci.oci.DifStack;
import com.pulumi.oci.oci.DifStackArgs;
import com.pulumi.oci.oci.inputs.DifStackAdbArgs;
import com.pulumi.oci.oci.inputs.DifStackDataflowArgs;
import com.pulumi.oci.oci.inputs.DifStackDataflowConnectionsArgs;
import com.pulumi.oci.oci.inputs.DifStackDataflowConnectionsConnectionDetailsArgs;
import com.pulumi.oci.oci.inputs.DifStackDataflowDriverShapeConfigArgs;
import com.pulumi.oci.oci.inputs.DifStackDataflowExecutorShapeConfigArgs;
import com.pulumi.oci.oci.inputs.DifStackGenaiArgs;
import com.pulumi.oci.oci.inputs.DifStackGgcArgs;
import com.pulumi.oci.oci.inputs.DifStackObjectstorageArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var testStack = new DifStack("testStack", DifStackArgs.builder()
            .compartmentId(compartmentId)
            .displayName(stackDisplayName)
            .services(stackServices)
            .stackTemplates(stackStackTemplates)
            .adbs(DifStackAdbArgs.builder()
                .adminPasswordId(testAdminPassword.id())
                .dataStorageSizeInTbs(stackAdbDataStorageSizeInTbs)
                .dbVersion(stackAdbDbVersion)
                .dbWorkload(stackAdbDbWorkload)
                .ecpu(stackAdbEcpu)
                .instanceId(stackAdbInstanceId)
                .isMtlsConnectionRequired(stackAdbIsMtlsConnectionRequired)
                .isPublic(stackAdbIsPublic)
                .subnetId(testSubnet.id())
                .toolsPublicAccess(stackAdbToolsPublicAccess)
                .artifactObjectStoragePath(stackAdbArtifactObjectStoragePath)
                .dbCredentials(DifStackAdbDbCredentialArgs.builder()
                    .userName(stackAdbDbCredentialsUserName)
                    .secretId(stackAdbDbCredentialsSecretId)
                    .userType(stackAdbDbCredentialsUserType)
                    .build())
                .build())
            .dataflows(DifStackDataflowArgs.builder()
                .driverShape(stackDataflowDriverShape)
                .executorShape(stackDataflowExecutorShape)
                .instanceId(stackDataflowInstanceId)
                .logBucketInstanceId(stackObjectstorageInstanceId)
                .numExecutors(stackDataflowNumExecutors)
                .sparkVersion(stackDataflowSparkVersion)
                .connections(DifStackDataflowConnectionsArgs.builder()
                    .connectionDetails(DifStackDataflowConnectionsConnectionDetailsArgs.builder()
                        .difDependencies(DifStackDataflowConnectionsConnectionDetailsDifDependencyArgs.builder()
                            .serviceInstanceId(stackDependencyInstanceId)
                            .serviceType(stackDataflowConnectionsConnectionDetailsDifDependenciesServiceType)
                            .build())
                        .domainNames(stackDataflowConnectionsConnectionDetailsDomainNames)
                        .build())
                    .subnetId(testSubnet.id())
                    .build())
                .driverShapeConfig(DifStackDataflowDriverShapeConfigArgs.builder()
                    .memoryInGbs(stackDataflowDriverShapeConfigMemoryInGbs)
                    .ocpus(stackDataflowDriverShapeConfigOcpus)
                    .build())
                .executorShapeConfig(DifStackDataflowExecutorShapeConfigArgs.builder()
                    .memoryInGbs(stackDataflowExecutorShapeConfigMemoryInGbs)
                    .ocpus(stackDataflowExecutorShapeConfigOcpus)
                    .build())
                .privateEndpointId(testPrivateEndpoint.id())
                .warehouseBucketInstanceId(stackObjectstorageInstanceId)
                .execute(stackDataflowExecute)
                .archiveUri(stackDataflowArchiveUri)
                .build())
            .definedTags(Map.of("Operations.CostCenter", "42"))
            .freeformTags(Map.of("Department", "Finance"))
            .genais(DifStackGenaiArgs.builder()
                .baseModel(stackGenaiBaseModel)
                .clusterType(stackGenaiClusterType)
                .instanceId(stackGenaiInstanceId)
                .ociRegion(stackGenaiOciRegion)
                .unitCount(stackGenaiUnitCount)
                .endpoints(DifStackGenaiEndpointArgs.builder()
                    .endpointName(stackGenaiEndpointName)
                    .isContentModerationEnabled(stackGenaiEndpointsIsContentModerationEnabled)
                    .build())
                .build())
            .ggcs(DifStackGgcArgs.builder()
                .instanceId(stackGgcsInstanceId)
                .ocpu(stackGgcsOcpu)
                .passwordSecretId(testSecret.id())
                .subnetId(testSubnet.id())
                .connections(DifStackGgcConnectionArgs.builder()
                    .connectionName(testConnection.name())
                    .connectionId(testConnection.id())
                    .difDependencies(DifStackGgcConnectionDifDependencyArgs.builder()
                        .serviceInstanceId(stackDependencyInstanceId)
                        .serviceType(stackGgcsConnectionsDifDependenciesServiceType)
                        .build())
                    .ggAdminSecretId(testSecret.id())
                    .build())
                .oggVersion(stackGgcsOggVersion)
                .publicSubnetId(testSubnet.id())
                .artifactObjectStoragePath(stackGgcsArtifactObjectStoragePath)
                .users(DifStackGgcUserArgs.builder()
                    .userName(stackGgcsUsersUserName)
                    .secretId(stackGgcsUsersSecretId)
                    .userType(stackGgcsUsersUserType)
                    .action(stackGgcsUsersAction)
                    .build())
                .sources(DifStackGgcSourceArgs.builder()
                    .sourceId(stackGgcsSourcesSourceId)
                    .action(stackGgcsSourcesAction)
                    .shouldStartSourceOperations(stackGgcsSourcesShouldStartSourceOperations)
                    .targetUri(stackGgcsSourcesTargetUri)
                    .targetConnectionName(stackGgcsSourcesTargetConnectionName)
                    .build())
                .targets(DifStackGgcTargetArgs.builder()
                    .targetId(stackGgcsTargetId)
                    .action(stackGgcsAction)
                    .shouldStartTargetOperations(stackGgcsShouldStartTargetOperations)
                    .sourceUri(stackGgcsSourceUri)
                    .sourceConnectionName(stackGgcsSourceConnectionName)
                    .build())
                .build())
            .notificationEmail(stackNotificationEmail)
            .objectstorages(DifStackObjectstorageArgs.builder()
                .instanceId(stackObjectstorageInstanceId)
                .objectVersioning(stackObjectstorageObjectVersioning)
                .storageTier(stackObjectstorageStorageTier)
                .autoTiering(stackObjectstorageAutoTiering)
                .build())
            .subnetId(stackDeployArtifactsSubnetId)
            .build());

    }
}

resources:
  testStack:
    type: oci:oci:DifStack
    name: test_stack
    properties:
      compartmentId: ${compartmentId}
      displayName: ${stackDisplayName}
      services: ${stackServices}
      stackTemplates: ${stackStackTemplates}
      adbs:
        - adminPasswordId: ${testAdminPassword.id}
          dataStorageSizeInTbs: ${stackAdbDataStorageSizeInTbs}
          dbVersion: ${stackAdbDbVersion}
          dbWorkload: ${stackAdbDbWorkload}
          ecpu: ${stackAdbEcpu}
          instanceId: ${stackAdbInstanceId}
          isMtlsConnectionRequired: ${stackAdbIsMtlsConnectionRequired}
          isPublic: ${stackAdbIsPublic}
          subnetId: ${testSubnet.id}
          toolsPublicAccess: ${stackAdbToolsPublicAccess}
          artifactObjectStoragePath: ${stackAdbArtifactObjectStoragePath}
          dbCredentials:
            - userName: ${stackAdbDbCredentialsUserName}
              secretId: ${stackAdbDbCredentialsSecretId}
              userType: ${stackAdbDbCredentialsUserType}
      dataflows:
        - driverShape: ${stackDataflowDriverShape}
          executorShape: ${stackDataflowExecutorShape}
          instanceId: ${stackDataflowInstanceId}
          logBucketInstanceId: ${stackObjectstorageInstanceId}
          numExecutors: ${stackDataflowNumExecutors}
          sparkVersion: ${stackDataflowSparkVersion}
          connections:
            connectionDetails:
              difDependencies:
                - serviceInstanceId: ${stackDependencyInstanceId}
                  serviceType: ${stackDataflowConnectionsConnectionDetailsDifDependenciesServiceType}
              domainNames: ${stackDataflowConnectionsConnectionDetailsDomainNames}
            subnetId: ${testSubnet.id}
          driverShapeConfig:
            memoryInGbs: ${stackDataflowDriverShapeConfigMemoryInGbs}
            ocpus: ${stackDataflowDriverShapeConfigOcpus}
          executorShapeConfig:
            memoryInGbs: ${stackDataflowExecutorShapeConfigMemoryInGbs}
            ocpus: ${stackDataflowExecutorShapeConfigOcpus}
          privateEndpointId: ${testPrivateEndpoint.id}
          warehouseBucketInstanceId: ${stackObjectstorageInstanceId}
          execute: ${stackDataflowExecute}
          archiveUri: ${stackDataflowArchiveUri}
      definedTags:
        Operations.CostCenter: '42'
      freeformTags:
        Department: Finance
      genais:
        - baseModel: ${stackGenaiBaseModel}
          clusterType: ${stackGenaiClusterType}
          instanceId: ${stackGenaiInstanceId}
          ociRegion: ${stackGenaiOciRegion}
          unitCount: ${stackGenaiUnitCount}
          endpoints:
            - endpointName: ${stackGenaiEndpointName}
              isContentModerationEnabled: ${stackGenaiEndpointsIsContentModerationEnabled}
      ggcs:
        - instanceId: ${stackGgcsInstanceId}
          ocpu: ${stackGgcsOcpu}
          passwordSecretId: ${testSecret.id}
          subnetId: ${testSubnet.id}
          connections:
            - connectionName: ${testConnection.name}
              connectionId: ${testConnection.id}
              difDependencies:
                - serviceInstanceId: ${stackDependencyInstanceId}
                  serviceType: ${stackGgcsConnectionsDifDependenciesServiceType}
              ggAdminSecretId: ${testSecret.id}
          oggVersion: ${stackGgcsOggVersion}
          publicSubnetId: ${testSubnet.id}
          artifactObjectStoragePath: ${stackGgcsArtifactObjectStoragePath}
          users:
            - userName: ${stackGgcsUsersUserName}
              secretId: ${stackGgcsUsersSecretId}
              userType: ${stackGgcsUsersUserType}
              action: ${stackGgcsUsersAction}
          sources:
            - sourceId: ${stackGgcsSourcesSourceId}
              action: ${stackGgcsSourcesAction}
              shouldStartSourceOperations: ${stackGgcsSourcesShouldStartSourceOperations}
              targetUri: ${stackGgcsSourcesTargetUri}
              targetConnectionName: ${stackGgcsSourcesTargetConnectionName}
          targets:
            - targetId: ${stackGgcsTargetId}
              action: ${stackGgcsAction}
              shouldStartTargetOperations: ${stackGgcsShouldStartTargetOperations}
              sourceUri: ${stackGgcsSourceUri}
              sourceConnectionName: ${stackGgcsSourceConnectionName}
      notificationEmail: ${stackNotificationEmail}
      objectstorages:
        - instanceId: ${stackObjectstorageInstanceId}
          objectVersioning: ${stackObjectstorageObjectVersioning}
          storageTier: ${stackObjectstorageStorageTier}
          autoTiering: ${stackObjectstorageAutoTiering}
      subnetId: ${stackDeployArtifactsSubnetId}

var difStackResource = new Oci.Oci.DifStack("difStackResource", new()
{
    DisplayName = "string",
    StackTemplates = new[]
    {
        "string",
    },
    CompartmentId = "string",
    Services = new[]
    {
        "string",
    },
    Dataflows = new[]
    {
        new Oci.Oci.Inputs.DifStackDataflowArgs
        {
            InstanceId = "string",
            SparkVersion = "string",
            DriverShape = "string",
            NumExecutors = 0,
            LogBucketInstanceId = "string",
            ExecutorShape = "string",
            DriverShapeConfig = new Oci.Oci.Inputs.DifStackDataflowDriverShapeConfigArgs
            {
                MemoryInGbs = 0,
                Ocpus = 0,
            },
            ExecutorShapeConfig = new Oci.Oci.Inputs.DifStackDataflowExecutorShapeConfigArgs
            {
                MemoryInGbs = 0,
                Ocpus = 0,
            },
            Execute = "string",
            ArchiveUri = "string",
            PrivateEndpointId = "string",
            Connections = new Oci.Oci.Inputs.DifStackDataflowConnectionsArgs
            {
                ConnectionDetails = new Oci.Oci.Inputs.DifStackDataflowConnectionsConnectionDetailsArgs
                {
                    DifDependencies = new[]
                    {
                        new Oci.Oci.Inputs.DifStackDataflowConnectionsConnectionDetailsDifDependencyArgs
                        {
                            ServiceInstanceId = "string",
                            ServiceType = "string",
                        },
                    },
                    DomainNames = new[]
                    {
                        "string",
                    },
                },
                SubnetId = "string",
            },
            WarehouseBucketInstanceId = "string",
        },
    },
    DeployArtifactsTrigger = 0,
    DefinedTags = 
    {
        { "string", "string" },
    },
    FreeformTags = 
    {
        { "string", "string" },
    },
    Genais = new[]
    {
        new Oci.Oci.Inputs.DifStackGenaiArgs
        {
            BaseModel = "string",
            ClusterType = "string",
            InstanceId = "string",
            OciRegion = "string",
            UnitCount = 0,
            Endpoints = new[]
            {
                new Oci.Oci.Inputs.DifStackGenaiEndpointArgs
                {
                    EndpointName = "string",
                    IsContentModerationEnabled = false,
                },
            },
        },
    },
    Ggcs = new[]
    {
        new Oci.Oci.Inputs.DifStackGgcArgs
        {
            InstanceId = "string",
            Ocpu = 0,
            PasswordSecretId = "string",
            SubnetId = "string",
            ArtifactObjectStoragePath = "string",
            Connections = new[]
            {
                new Oci.Oci.Inputs.DifStackGgcConnectionArgs
                {
                    ConnectionName = "string",
                    ConnectionId = "string",
                    DifDependencies = new[]
                    {
                        new Oci.Oci.Inputs.DifStackGgcConnectionDifDependencyArgs
                        {
                            ServiceInstanceId = "string",
                            ServiceType = "string",
                        },
                    },
                    GgAdminSecretId = "string",
                },
            },
            OggVersion = "string",
            PublicSubnetId = "string",
            Sources = new[]
            {
                new Oci.Oci.Inputs.DifStackGgcSourceArgs
                {
                    Action = "string",
                    ShouldStartSourceOperations = false,
                    SourceId = "string",
                    TargetConnectionName = "string",
                    TargetUri = "string",
                },
            },
            Targets = new[]
            {
                new Oci.Oci.Inputs.DifStackGgcTargetArgs
                {
                    Action = "string",
                    ShouldStartTargetOperations = false,
                    TargetId = "string",
                    SourceConnectionName = "string",
                    SourceUri = "string",
                },
            },
            Users = new[]
            {
                new Oci.Oci.Inputs.DifStackGgcUserArgs
                {
                    Action = "string",
                    SecretId = "string",
                    UserName = "string",
                    UserType = "string",
                },
            },
        },
    },
    NotificationEmail = "string",
    Objectstorages = new[]
    {
        new Oci.Oci.Inputs.DifStackObjectstorageArgs
        {
            InstanceId = "string",
            ObjectVersioning = "string",
            StorageTier = "string",
            AutoTiering = "string",
        },
    },
    Adbs = new[]
    {
        new Oci.Oci.Inputs.DifStackAdbArgs
        {
            AdminPasswordId = "string",
            DataStorageSizeInTbs = 0,
            DbVersion = "string",
            DbWorkload = "string",
            Ecpu = 0,
            InstanceId = "string",
            ArtifactObjectStoragePath = "string",
            DbCredentials = new[]
            {
                new Oci.Oci.Inputs.DifStackAdbDbCredentialArgs
                {
                    SecretId = "string",
                    UserName = "string",
                    UserType = "string",
                },
            },
            IsMtlsConnectionRequired = false,
            IsPublic = false,
            SubnetId = "string",
            ToolsPublicAccess = "string",
        },
    },
    AddServiceTrigger = 0,
    SubnetId = "string",
});

example, err := oci.NewDifStack(ctx, "difStackResource", &oci.DifStackArgs{
	DisplayName: pulumi.String("string"),
	StackTemplates: pulumi.StringArray{
		pulumi.String("string"),
	},
	CompartmentId: pulumi.String("string"),
	Services: pulumi.StringArray{
		pulumi.String("string"),
	},
	Dataflows: oci.DifStackDataflowArray{
		&oci.DifStackDataflowArgs{
			InstanceId:          pulumi.String("string"),
			SparkVersion:        pulumi.String("string"),
			DriverShape:         pulumi.String("string"),
			NumExecutors:        pulumi.Int(0),
			LogBucketInstanceId: pulumi.String("string"),
			ExecutorShape:       pulumi.String("string"),
			DriverShapeConfig: &oci.DifStackDataflowDriverShapeConfigArgs{
				MemoryInGbs: pulumi.Int(0),
				Ocpus:       pulumi.Int(0),
			},
			ExecutorShapeConfig: &oci.DifStackDataflowExecutorShapeConfigArgs{
				MemoryInGbs: pulumi.Int(0),
				Ocpus:       pulumi.Int(0),
			},
			Execute:           pulumi.String("string"),
			ArchiveUri:        pulumi.String("string"),
			PrivateEndpointId: pulumi.String("string"),
			Connections: &oci.DifStackDataflowConnectionsArgs{
				ConnectionDetails: &oci.DifStackDataflowConnectionsConnectionDetailsArgs{
					DifDependencies: oci.DifStackDataflowConnectionsConnectionDetailsDifDependencyArray{
						&oci.DifStackDataflowConnectionsConnectionDetailsDifDependencyArgs{
							ServiceInstanceId: pulumi.String("string"),
							ServiceType:       pulumi.String("string"),
						},
					},
					DomainNames: pulumi.StringArray{
						pulumi.String("string"),
					},
				},
				SubnetId: pulumi.String("string"),
			},
			WarehouseBucketInstanceId: pulumi.String("string"),
		},
	},
	DeployArtifactsTrigger: pulumi.Int(0),
	DefinedTags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	FreeformTags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Genais: oci.DifStackGenaiArray{
		&oci.DifStackGenaiArgs{
			BaseModel:   pulumi.String("string"),
			ClusterType: pulumi.String("string"),
			InstanceId:  pulumi.String("string"),
			OciRegion:   pulumi.String("string"),
			UnitCount:   pulumi.Int(0),
			Endpoints: oci.DifStackGenaiEndpointArray{
				&oci.DifStackGenaiEndpointArgs{
					EndpointName:               pulumi.String("string"),
					IsContentModerationEnabled: pulumi.Bool(false),
				},
			},
		},
	},
	Ggcs: oci.DifStackGgcArray{
		&oci.DifStackGgcArgs{
			InstanceId:                pulumi.String("string"),
			Ocpu:                      pulumi.Int(0),
			PasswordSecretId:          pulumi.String("string"),
			SubnetId:                  pulumi.String("string"),
			ArtifactObjectStoragePath: pulumi.String("string"),
			Connections: oci.DifStackGgcConnectionArray{
				&oci.DifStackGgcConnectionArgs{
					ConnectionName: pulumi.String("string"),
					ConnectionId:   pulumi.String("string"),
					DifDependencies: oci.DifStackGgcConnectionDifDependencyArray{
						&oci.DifStackGgcConnectionDifDependencyArgs{
							ServiceInstanceId: pulumi.String("string"),
							ServiceType:       pulumi.String("string"),
						},
					},
					GgAdminSecretId: pulumi.String("string"),
				},
			},
			OggVersion:     pulumi.String("string"),
			PublicSubnetId: pulumi.String("string"),
			Sources: oci.DifStackGgcSourceArray{
				&oci.DifStackGgcSourceArgs{
					Action:                      pulumi.String("string"),
					ShouldStartSourceOperations: pulumi.Bool(false),
					SourceId:                    pulumi.String("string"),
					TargetConnectionName:        pulumi.String("string"),
					TargetUri:                   pulumi.String("string"),
				},
			},
			Targets: oci.DifStackGgcTargetArray{
				&oci.DifStackGgcTargetArgs{
					Action:                      pulumi.String("string"),
					ShouldStartTargetOperations: pulumi.Bool(false),
					TargetId:                    pulumi.String("string"),
					SourceConnectionName:        pulumi.String("string"),
					SourceUri:                   pulumi.String("string"),
				},
			},
			Users: oci.DifStackGgcUserArray{
				&oci.DifStackGgcUserArgs{
					Action:   pulumi.String("string"),
					SecretId: pulumi.String("string"),
					UserName: pulumi.String("string"),
					UserType: pulumi.String("string"),
				},
			},
		},
	},
	NotificationEmail: pulumi.String("string"),
	Objectstorages: oci.DifStackObjectstorageArray{
		&oci.DifStackObjectstorageArgs{
			InstanceId:       pulumi.String("string"),
			ObjectVersioning: pulumi.String("string"),
			StorageTier:      pulumi.String("string"),
			AutoTiering:      pulumi.String("string"),
		},
	},
	Adbs: oci.DifStackAdbArray{
		&oci.DifStackAdbArgs{
			AdminPasswordId:           pulumi.String("string"),
			DataStorageSizeInTbs:      pulumi.Int(0),
			DbVersion:                 pulumi.String("string"),
			DbWorkload:                pulumi.String("string"),
			Ecpu:                      pulumi.Int(0),
			InstanceId:                pulumi.String("string"),
			ArtifactObjectStoragePath: pulumi.String("string"),
			DbCredentials: oci.DifStackAdbDbCredentialArray{
				&oci.DifStackAdbDbCredentialArgs{
					SecretId: pulumi.String("string"),
					UserName: pulumi.String("string"),
					UserType: pulumi.String("string"),
				},
			},
			IsMtlsConnectionRequired: pulumi.Bool(false),
			IsPublic:                 pulumi.Bool(false),
			SubnetId:                 pulumi.String("string"),
			ToolsPublicAccess:        pulumi.String("string"),
		},
	},
	AddServiceTrigger: pulumi.Int(0),
	SubnetId:          pulumi.String("string"),
})