snowflake.StageInternal

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

// basic resource
const basic = new snowflake.StageInternal("basic", {
    name: "my_internal_stage",
    database: "my_database",
    schema: "my_schema",
});
// complete resource
const complete = new snowflake.StageInternal("complete", {
    name: "complete_stage",
    database: "my_database",
    schema: "my_schema",
    encryption: {
        snowflakeFull: {},
    },
    directory: {
        enable: true,
        autoRefresh: "false",
    },
    comment: "Fully configured internal stage",
});
// resource with inline CSV file format
const withCsvFormat = new snowflake.StageInternal("with_csv_format", {
    name: "csv_format_stage",
    database: "my_database",
    schema: "my_schema",
    fileFormat: {
        csv: {
            compression: "GZIP",
            recordDelimiter: "\n",
            fieldDelimiter: "|",
            multiLine: "false",
            fileExtension: ".csv",
            skipHeader: 1,
            skipBlankLines: "true",
            dateFormat: "AUTO",
            timeFormat: "AUTO",
            timestampFormat: "AUTO",
            binaryFormat: "HEX",
            escape: "\\",
            escapeUnenclosedField: "\\",
            trimSpace: "false",
            fieldOptionallyEnclosedBy: "\"",
            nullIfs: [
                "NULL",
                "",
            ],
            errorOnColumnCountMismatch: "true",
            replaceInvalidCharacters: "false",
            emptyFieldAsNull: "true",
            skipByteOrderMark: "true",
            encoding: "UTF8",
        },
    },
});
// resource with inline JSON file format
const withJsonFormat = new snowflake.StageInternal("with_json_format", {
    name: "json_format_stage",
    database: "my_database",
    schema: "my_schema",
    fileFormat: {
        json: {
            compression: "AUTO",
            dateFormat: "AUTO",
            timeFormat: "AUTO",
            timestampFormat: "AUTO",
            binaryFormat: "HEX",
            trimSpace: "false",
            multiLine: "false",
            nullIfs: [
                "NULL",
                "",
            ],
            fileExtension: ".json",
            enableOctal: "false",
            allowDuplicate: "false",
            stripOuterArray: "false",
            stripNullValues: "false",
            replaceInvalidCharacters: "false",
            skipByteOrderMark: "false",
        },
    },
});
// resource with inline AVRO file format
const withAvroFormat = new snowflake.StageInternal("with_avro_format", {
    name: "avro_format_stage",
    database: "my_database",
    schema: "my_schema",
    fileFormat: {
        avro: {
            compression: "GZIP",
            trimSpace: "false",
            replaceInvalidCharacters: "false",
            nullIfs: [
                "NULL",
                "",
            ],
        },
    },
});
// resource with inline ORC file format
const withOrcFormat = new snowflake.StageInternal("with_orc_format", {
    name: "orc_format_stage",
    database: "my_database",
    schema: "my_schema",
    fileFormat: {
        orc: {
            trimSpace: "false",
            replaceInvalidCharacters: "false",
            nullIfs: [
                "NULL",
                "",
            ],
        },
    },
});
// resource with inline Parquet file format
const withParquetFormat = new snowflake.StageInternal("with_parquet_format", {
    name: "parquet_format_stage",
    database: "my_database",
    schema: "my_schema",
    fileFormat: {
        parquet: {
            compression: "SNAPPY",
            binaryAsText: "true",
            useLogicalType: "true",
            trimSpace: "false",
            useVectorizedScanner: "false",
            replaceInvalidCharacters: "false",
            nullIfs: [
                "NULL",
                "",
            ],
        },
    },
});
// resource with inline XML file format
const withXmlFormat = new snowflake.StageInternal("with_xml_format", {
    name: "xml_format_stage",
    database: "my_database",
    schema: "my_schema",
    fileFormat: {
        xml: {
            compression: "AUTO",
            preserveSpace: "false",
            stripOuterElement: "false",
            disableAutoConvert: "false",
            replaceInvalidCharacters: "false",
            skipByteOrderMark: "false",
        },
    },
});
// resource with named file format
const withNamedFormat = new snowflake.StageInternal("with_named_format", {
    name: "named_format_stage",
    database: "my_database",
    schema: "my_schema",
    fileFormat: {
        formatName: test.fullyQualifiedName,
    },
});

import pulumi
import pulumi_snowflake as snowflake

# basic resource
basic = snowflake.StageInternal("basic",
    name="my_internal_stage",
    database="my_database",
    schema="my_schema")
# complete resource
complete = snowflake.StageInternal("complete",
    name="complete_stage",
    database="my_database",
    schema="my_schema",
    encryption={
        "snowflake_full": {},
    },
    directory={
        "enable": True,
        "auto_refresh": "false",
    },
    comment="Fully configured internal stage")
# resource with inline CSV file format
with_csv_format = snowflake.StageInternal("with_csv_format",
    name="csv_format_stage",
    database="my_database",
    schema="my_schema",
    file_format={
        "csv": {
            "compression": "GZIP",
            "record_delimiter": "\n",
            "field_delimiter": "|",
            "multi_line": "false",
            "file_extension": ".csv",
            "skip_header": 1,
            "skip_blank_lines": "true",
            "date_format": "AUTO",
            "time_format": "AUTO",
            "timestamp_format": "AUTO",
            "binary_format": "HEX",
            "escape": "\\",
            "escape_unenclosed_field": "\\",
            "trim_space": "false",
            "field_optionally_enclosed_by": "\"",
            "null_ifs": [
                "NULL",
                "",
            ],
            "error_on_column_count_mismatch": "true",
            "replace_invalid_characters": "false",
            "empty_field_as_null": "true",
            "skip_byte_order_mark": "true",
            "encoding": "UTF8",
        },
    })
# resource with inline JSON file format
with_json_format = snowflake.StageInternal("with_json_format",
    name="json_format_stage",
    database="my_database",
    schema="my_schema",
    file_format={
        "json": {
            "compression": "AUTO",
            "date_format": "AUTO",
            "time_format": "AUTO",
            "timestamp_format": "AUTO",
            "binary_format": "HEX",
            "trim_space": "false",
            "multi_line": "false",
            "null_ifs": [
                "NULL",
                "",
            ],
            "file_extension": ".json",
            "enable_octal": "false",
            "allow_duplicate": "false",
            "strip_outer_array": "false",
            "strip_null_values": "false",
            "replace_invalid_characters": "false",
            "skip_byte_order_mark": "false",
        },
    })
# resource with inline AVRO file format
with_avro_format = snowflake.StageInternal("with_avro_format",
    name="avro_format_stage",
    database="my_database",
    schema="my_schema",
    file_format={
        "avro": {
            "compression": "GZIP",
            "trim_space": "false",
            "replace_invalid_characters": "false",
            "null_ifs": [
                "NULL",
                "",
            ],
        },
    })
# resource with inline ORC file format
with_orc_format = snowflake.StageInternal("with_orc_format",
    name="orc_format_stage",
    database="my_database",
    schema="my_schema",
    file_format={
        "orc": {
            "trim_space": "false",
            "replace_invalid_characters": "false",
            "null_ifs": [
                "NULL",
                "",
            ],
        },
    })
# resource with inline Parquet file format
with_parquet_format = snowflake.StageInternal("with_parquet_format",
    name="parquet_format_stage",
    database="my_database",
    schema="my_schema",
    file_format={
        "parquet": {
            "compression": "SNAPPY",
            "binary_as_text": "true",
            "use_logical_type": "true",
            "trim_space": "false",
            "use_vectorized_scanner": "false",
            "replace_invalid_characters": "false",
            "null_ifs": [
                "NULL",
                "",
            ],
        },
    })
# resource with inline XML file format
with_xml_format = snowflake.StageInternal("with_xml_format",
    name="xml_format_stage",
    database="my_database",
    schema="my_schema",
    file_format={
        "xml": {
            "compression": "AUTO",
            "preserve_space": "false",
            "strip_outer_element": "false",
            "disable_auto_convert": "false",
            "replace_invalid_characters": "false",
            "skip_byte_order_mark": "false",
        },
    })
# resource with named file format
with_named_format = snowflake.StageInternal("with_named_format",
    name="named_format_stage",
    database="my_database",
    schema="my_schema",
    file_format={
        "format_name": test["fullyQualifiedName"],
    })

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// basic resource
		_, err := snowflake.NewStageInternal(ctx, "basic", &snowflake.StageInternalArgs{
			Name:     pulumi.String("my_internal_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
		})
		if err != nil {
			return err
		}
		// complete resource
		_, err = snowflake.NewStageInternal(ctx, "complete", &snowflake.StageInternalArgs{
			Name:     pulumi.String("complete_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			Encryption: &snowflake.StageInternalEncryptionArgs{
				SnowflakeFull: &snowflake.StageInternalEncryptionSnowflakeFullArgs{},
			},
			Directory: &snowflake.StageInternalDirectoryArgs{
				Enable:      pulumi.Bool(true),
				AutoRefresh: pulumi.String("false"),
			},
			Comment: pulumi.String("Fully configured internal stage"),
		})
		if err != nil {
			return err
		}
		// resource with inline CSV file format
		_, err = snowflake.NewStageInternal(ctx, "with_csv_format", &snowflake.StageInternalArgs{
			Name:     pulumi.String("csv_format_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			FileFormat: &snowflake.StageInternalFileFormatArgs{
				Csv: &snowflake.StageInternalFileFormatCsvArgs{
					Compression:               pulumi.String("GZIP"),
					RecordDelimiter:           pulumi.String("\n"),
					FieldDelimiter:            pulumi.String("|"),
					MultiLine:                 pulumi.String("false"),
					FileExtension:             pulumi.String(".csv"),
					SkipHeader:                pulumi.Int(1),
					SkipBlankLines:            pulumi.String("true"),
					DateFormat:                pulumi.String("AUTO"),
					TimeFormat:                pulumi.String("AUTO"),
					TimestampFormat:           pulumi.String("AUTO"),
					BinaryFormat:              pulumi.String("HEX"),
					Escape:                    pulumi.String("\\"),
					EscapeUnenclosedField:     pulumi.String("\\"),
					TrimSpace:                 pulumi.String("false"),
					FieldOptionallyEnclosedBy: pulumi.String("\""),
					NullIfs: pulumi.StringArray{
						pulumi.String("NULL"),
						pulumi.String(""),
					},
					ErrorOnColumnCountMismatch: pulumi.String("true"),
					ReplaceInvalidCharacters:   pulumi.String("false"),
					EmptyFieldAsNull:           pulumi.String("true"),
					SkipByteOrderMark:          pulumi.String("true"),
					Encoding:                   pulumi.String("UTF8"),
				},
			},
		})
		if err != nil {
			return err
		}
		// resource with inline JSON file format
		_, err = snowflake.NewStageInternal(ctx, "with_json_format", &snowflake.StageInternalArgs{
			Name:     pulumi.String("json_format_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			FileFormat: &snowflake.StageInternalFileFormatArgs{
				Json: &snowflake.StageInternalFileFormatJsonArgs{
					Compression:     pulumi.String("AUTO"),
					DateFormat:      pulumi.String("AUTO"),
					TimeFormat:      pulumi.String("AUTO"),
					TimestampFormat: pulumi.String("AUTO"),
					BinaryFormat:    pulumi.String("HEX"),
					TrimSpace:       pulumi.String("false"),
					MultiLine:       pulumi.String("false"),
					NullIfs: pulumi.StringArray{
						pulumi.String("NULL"),
						pulumi.String(""),
					},
					FileExtension:            pulumi.String(".json"),
					EnableOctal:              pulumi.String("false"),
					AllowDuplicate:           pulumi.String("false"),
					StripOuterArray:          pulumi.String("false"),
					StripNullValues:          pulumi.String("false"),
					ReplaceInvalidCharacters: pulumi.String("false"),
					SkipByteOrderMark:        pulumi.String("false"),
				},
			},
		})
		if err != nil {
			return err
		}
		// resource with inline AVRO file format
		_, err = snowflake.NewStageInternal(ctx, "with_avro_format", &snowflake.StageInternalArgs{
			Name:     pulumi.String("avro_format_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			FileFormat: &snowflake.StageInternalFileFormatArgs{
				Avro: &snowflake.StageInternalFileFormatAvroArgs{
					Compression:              pulumi.String("GZIP"),
					TrimSpace:                pulumi.String("false"),
					ReplaceInvalidCharacters: pulumi.String("false"),
					NullIfs: pulumi.StringArray{
						pulumi.String("NULL"),
						pulumi.String(""),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// resource with inline ORC file format
		_, err = snowflake.NewStageInternal(ctx, "with_orc_format", &snowflake.StageInternalArgs{
			Name:     pulumi.String("orc_format_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			FileFormat: &snowflake.StageInternalFileFormatArgs{
				Orc: &snowflake.StageInternalFileFormatOrcArgs{
					TrimSpace:                pulumi.String("false"),
					ReplaceInvalidCharacters: pulumi.String("false"),
					NullIfs: pulumi.StringArray{
						pulumi.String("NULL"),
						pulumi.String(""),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// resource with inline Parquet file format
		_, err = snowflake.NewStageInternal(ctx, "with_parquet_format", &snowflake.StageInternalArgs{
			Name:     pulumi.String("parquet_format_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			FileFormat: &snowflake.StageInternalFileFormatArgs{
				Parquet: &snowflake.StageInternalFileFormatParquetArgs{
					Compression:              pulumi.String("SNAPPY"),
					BinaryAsText:             pulumi.String("true"),
					UseLogicalType:           pulumi.String("true"),
					TrimSpace:                pulumi.String("false"),
					UseVectorizedScanner:     pulumi.String("false"),
					ReplaceInvalidCharacters: pulumi.String("false"),
					NullIfs: pulumi.StringArray{
						pulumi.String("NULL"),
						pulumi.String(""),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// resource with inline XML file format
		_, err = snowflake.NewStageInternal(ctx, "with_xml_format", &snowflake.StageInternalArgs{
			Name:     pulumi.String("xml_format_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			FileFormat: &snowflake.StageInternalFileFormatArgs{
				Xml: &snowflake.StageInternalFileFormatXmlArgs{
					Compression:              pulumi.String("AUTO"),
					PreserveSpace:            pulumi.String("false"),
					StripOuterElement:        pulumi.String("false"),
					DisableAutoConvert:       pulumi.String("false"),
					ReplaceInvalidCharacters: pulumi.String("false"),
					SkipByteOrderMark:        pulumi.String("false"),
				},
			},
		})
		if err != nil {
			return err
		}
		// resource with named file format
		_, err = snowflake.NewStageInternal(ctx, "with_named_format", &snowflake.StageInternalArgs{
			Name:     pulumi.String("named_format_stage"),
			Database: pulumi.String("my_database"),
			Schema:   pulumi.String("my_schema"),
			FileFormat: &snowflake.StageInternalFileFormatArgs{
				FormatName: pulumi.Any(test.FullyQualifiedName),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // basic resource
    var basic = new Snowflake.StageInternal("basic", new()
    {
        Name = "my_internal_stage",
        Database = "my_database",
        Schema = "my_schema",
    });

    // complete resource
    var complete = new Snowflake.StageInternal("complete", new()
    {
        Name = "complete_stage",
        Database = "my_database",
        Schema = "my_schema",
        Encryption = new Snowflake.Inputs.StageInternalEncryptionArgs
        {
            SnowflakeFull = null,
        },
        Directory = new Snowflake.Inputs.StageInternalDirectoryArgs
        {
            Enable = true,
            AutoRefresh = "false",
        },
        Comment = "Fully configured internal stage",
    });

    // resource with inline CSV file format
    var withCsvFormat = new Snowflake.StageInternal("with_csv_format", new()
    {
        Name = "csv_format_stage",
        Database = "my_database",
        Schema = "my_schema",
        FileFormat = new Snowflake.Inputs.StageInternalFileFormatArgs
        {
            Csv = new Snowflake.Inputs.StageInternalFileFormatCsvArgs
            {
                Compression = "GZIP",
                RecordDelimiter = @"
",
                FieldDelimiter = "|",
                MultiLine = "false",
                FileExtension = ".csv",
                SkipHeader = 1,
                SkipBlankLines = "true",
                DateFormat = "AUTO",
                TimeFormat = "AUTO",
                TimestampFormat = "AUTO",
                BinaryFormat = "HEX",
                Escape = "\\",
                EscapeUnenclosedField = "\\",
                TrimSpace = "false",
                FieldOptionallyEnclosedBy = "\"",
                NullIfs = new[]
                {
                    "NULL",
                    "",
                },
                ErrorOnColumnCountMismatch = "true",
                ReplaceInvalidCharacters = "false",
                EmptyFieldAsNull = "true",
                SkipByteOrderMark = "true",
                Encoding = "UTF8",
            },
        },
    });

    // resource with inline JSON file format
    var withJsonFormat = new Snowflake.StageInternal("with_json_format", new()
    {
        Name = "json_format_stage",
        Database = "my_database",
        Schema = "my_schema",
        FileFormat = new Snowflake.Inputs.StageInternalFileFormatArgs
        {
            Json = new Snowflake.Inputs.StageInternalFileFormatJsonArgs
            {
                Compression = "AUTO",
                DateFormat = "AUTO",
                TimeFormat = "AUTO",
                TimestampFormat = "AUTO",
                BinaryFormat = "HEX",
                TrimSpace = "false",
                MultiLine = "false",
                NullIfs = new[]
                {
                    "NULL",
                    "",
                },
                FileExtension = ".json",
                EnableOctal = "false",
                AllowDuplicate = "false",
                StripOuterArray = "false",
                StripNullValues = "false",
                ReplaceInvalidCharacters = "false",
                SkipByteOrderMark = "false",
            },
        },
    });

    // resource with inline AVRO file format
    var withAvroFormat = new Snowflake.StageInternal("with_avro_format", new()
    {
        Name = "avro_format_stage",
        Database = "my_database",
        Schema = "my_schema",
        FileFormat = new Snowflake.Inputs.StageInternalFileFormatArgs
        {
            Avro = new Snowflake.Inputs.StageInternalFileFormatAvroArgs
            {
                Compression = "GZIP",
                TrimSpace = "false",
                ReplaceInvalidCharacters = "false",
                NullIfs = new[]
                {
                    "NULL",
                    "",
                },
            },
        },
    });

    // resource with inline ORC file format
    var withOrcFormat = new Snowflake.StageInternal("with_orc_format", new()
    {
        Name = "orc_format_stage",
        Database = "my_database",
        Schema = "my_schema",
        FileFormat = new Snowflake.Inputs.StageInternalFileFormatArgs
        {
            Orc = new Snowflake.Inputs.StageInternalFileFormatOrcArgs
            {
                TrimSpace = "false",
                ReplaceInvalidCharacters = "false",
                NullIfs = new[]
                {
                    "NULL",
                    "",
                },
            },
        },
    });

    // resource with inline Parquet file format
    var withParquetFormat = new Snowflake.StageInternal("with_parquet_format", new()
    {
        Name = "parquet_format_stage",
        Database = "my_database",
        Schema = "my_schema",
        FileFormat = new Snowflake.Inputs.StageInternalFileFormatArgs
        {
            Parquet = new Snowflake.Inputs.StageInternalFileFormatParquetArgs
            {
                Compression = "SNAPPY",
                BinaryAsText = "true",
                UseLogicalType = "true",
                TrimSpace = "false",
                UseVectorizedScanner = "false",
                ReplaceInvalidCharacters = "false",
                NullIfs = new[]
                {
                    "NULL",
                    "",
                },
            },
        },
    });

    // resource with inline XML file format
    var withXmlFormat = new Snowflake.StageInternal("with_xml_format", new()
    {
        Name = "xml_format_stage",
        Database = "my_database",
        Schema = "my_schema",
        FileFormat = new Snowflake.Inputs.StageInternalFileFormatArgs
        {
            Xml = new Snowflake.Inputs.StageInternalFileFormatXmlArgs
            {
                Compression = "AUTO",
                PreserveSpace = "false",
                StripOuterElement = "false",
                DisableAutoConvert = "false",
                ReplaceInvalidCharacters = "false",
                SkipByteOrderMark = "false",
            },
        },
    });

    // resource with named file format
    var withNamedFormat = new Snowflake.StageInternal("with_named_format", new()
    {
        Name = "named_format_stage",
        Database = "my_database",
        Schema = "my_schema",
        FileFormat = new Snowflake.Inputs.StageInternalFileFormatArgs
        {
            FormatName = test.FullyQualifiedName,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.snowflake.StageInternal;
import com.pulumi.snowflake.StageInternalArgs;
import com.pulumi.snowflake.inputs.StageInternalEncryptionArgs;
import com.pulumi.snowflake.inputs.StageInternalEncryptionSnowflakeFullArgs;
import com.pulumi.snowflake.inputs.StageInternalDirectoryArgs;
import com.pulumi.snowflake.inputs.StageInternalFileFormatArgs;
import com.pulumi.snowflake.inputs.StageInternalFileFormatCsvArgs;
import com.pulumi.snowflake.inputs.StageInternalFileFormatJsonArgs;
import com.pulumi.snowflake.inputs.StageInternalFileFormatAvroArgs;
import com.pulumi.snowflake.inputs.StageInternalFileFormatOrcArgs;
import com.pulumi.snowflake.inputs.StageInternalFileFormatParquetArgs;
import com.pulumi.snowflake.inputs.StageInternalFileFormatXmlArgs;
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) {
        // basic resource
        var basic = new StageInternal("basic", StageInternalArgs.builder()
            .name("my_internal_stage")
            .database("my_database")
            .schema("my_schema")
            .build());

        // complete resource
        var complete = new StageInternal("complete", StageInternalArgs.builder()
            .name("complete_stage")
            .database("my_database")
            .schema("my_schema")
            .encryption(StageInternalEncryptionArgs.builder()
                .snowflakeFull(StageInternalEncryptionSnowflakeFullArgs.builder()
                    .build())
                .build())
            .directory(StageInternalDirectoryArgs.builder()
                .enable(true)
                .autoRefresh("false")
                .build())
            .comment("Fully configured internal stage")
            .build());

        // resource with inline CSV file format
        var withCsvFormat = new StageInternal("withCsvFormat", StageInternalArgs.builder()
            .name("csv_format_stage")
            .database("my_database")
            .schema("my_schema")
            .fileFormat(StageInternalFileFormatArgs.builder()
                .csv(StageInternalFileFormatCsvArgs.builder()
                    .compression("GZIP")
                    .recordDelimiter("""

                    """)
                    .fieldDelimiter("|")
                    .multiLine("false")
                    .fileExtension(".csv")
                    .skipHeader(1)
                    .skipBlankLines("true")
                    .dateFormat("AUTO")
                    .timeFormat("AUTO")
                    .timestampFormat("AUTO")
                    .binaryFormat("HEX")
                    .escape("\\")
                    .escapeUnenclosedField("\\")
                    .trimSpace("false")
                    .fieldOptionallyEnclosedBy("\"")
                    .nullIfs(                    
                        "NULL",
                        "")
                    .errorOnColumnCountMismatch("true")
                    .replaceInvalidCharacters("false")
                    .emptyFieldAsNull("true")
                    .skipByteOrderMark("true")
                    .encoding("UTF8")
                    .build())
                .build())
            .build());

        // resource with inline JSON file format
        var withJsonFormat = new StageInternal("withJsonFormat", StageInternalArgs.builder()
            .name("json_format_stage")
            .database("my_database")
            .schema("my_schema")
            .fileFormat(StageInternalFileFormatArgs.builder()
                .json(StageInternalFileFormatJsonArgs.builder()
                    .compression("AUTO")
                    .dateFormat("AUTO")
                    .timeFormat("AUTO")
                    .timestampFormat("AUTO")
                    .binaryFormat("HEX")
                    .trimSpace("false")
                    .multiLine("false")
                    .nullIfs(                    
                        "NULL",
                        "")
                    .fileExtension(".json")
                    .enableOctal("false")
                    .allowDuplicate("false")
                    .stripOuterArray("false")
                    .stripNullValues("false")
                    .replaceInvalidCharacters("false")
                    .skipByteOrderMark("false")
                    .build())
                .build())
            .build());

        // resource with inline AVRO file format
        var withAvroFormat = new StageInternal("withAvroFormat", StageInternalArgs.builder()
            .name("avro_format_stage")
            .database("my_database")
            .schema("my_schema")
            .fileFormat(StageInternalFileFormatArgs.builder()
                .avro(StageInternalFileFormatAvroArgs.builder()
                    .compression("GZIP")
                    .trimSpace("false")
                    .replaceInvalidCharacters("false")
                    .nullIfs(                    
                        "NULL",
                        "")
                    .build())
                .build())
            .build());

        // resource with inline ORC file format
        var withOrcFormat = new StageInternal("withOrcFormat", StageInternalArgs.builder()
            .name("orc_format_stage")
            .database("my_database")
            .schema("my_schema")
            .fileFormat(StageInternalFileFormatArgs.builder()
                .orc(StageInternalFileFormatOrcArgs.builder()
                    .trimSpace("false")
                    .replaceInvalidCharacters("false")
                    .nullIfs(                    
                        "NULL",
                        "")
                    .build())
                .build())
            .build());

        // resource with inline Parquet file format
        var withParquetFormat = new StageInternal("withParquetFormat", StageInternalArgs.builder()
            .name("parquet_format_stage")
            .database("my_database")
            .schema("my_schema")
            .fileFormat(StageInternalFileFormatArgs.builder()
                .parquet(StageInternalFileFormatParquetArgs.builder()
                    .compression("SNAPPY")
                    .binaryAsText("true")
                    .useLogicalType("true")
                    .trimSpace("false")
                    .useVectorizedScanner("false")
                    .replaceInvalidCharacters("false")
                    .nullIfs(                    
                        "NULL",
                        "")
                    .build())
                .build())
            .build());

        // resource with inline XML file format
        var withXmlFormat = new StageInternal("withXmlFormat", StageInternalArgs.builder()
            .name("xml_format_stage")
            .database("my_database")
            .schema("my_schema")
            .fileFormat(StageInternalFileFormatArgs.builder()
                .xml(StageInternalFileFormatXmlArgs.builder()
                    .compression("AUTO")
                    .preserveSpace("false")
                    .stripOuterElement("false")
                    .disableAutoConvert("false")
                    .replaceInvalidCharacters("false")
                    .skipByteOrderMark("false")
                    .build())
                .build())
            .build());

        // resource with named file format
        var withNamedFormat = new StageInternal("withNamedFormat", StageInternalArgs.builder()
            .name("named_format_stage")
            .database("my_database")
            .schema("my_schema")
            .fileFormat(StageInternalFileFormatArgs.builder()
                .formatName(test.fullyQualifiedName())
                .build())
            .build());

    }
}

resources:
  # basic resource
  basic:
    type: snowflake:StageInternal
    properties:
      name: my_internal_stage
      database: my_database
      schema: my_schema
  # complete resource
  complete:
    type: snowflake:StageInternal
    properties:
      name: complete_stage
      database: my_database
      schema: my_schema
      encryption:
        snowflakeFull: {}
      directory:
        enable: true
        autoRefresh: false
      comment: Fully configured internal stage
  # resource with inline CSV file format
  withCsvFormat:
    type: snowflake:StageInternal
    name: with_csv_format
    properties:
      name: csv_format_stage
      database: my_database
      schema: my_schema
      fileFormat:
        csv:
          compression: GZIP
          recordDelimiter: |2+
          fieldDelimiter: '|'
          multiLine: 'false'
          fileExtension: .csv
          skipHeader: 1
          skipBlankLines: 'true'
          dateFormat: AUTO
          timeFormat: AUTO
          timestampFormat: AUTO
          binaryFormat: HEX
          escape: \
          escapeUnenclosedField: \
          trimSpace: 'false'
          fieldOptionallyEnclosedBy: '"'
          nullIfs:
            - NULL
            - ""
          errorOnColumnCountMismatch: 'true'
          replaceInvalidCharacters: 'false'
          emptyFieldAsNull: 'true'
          skipByteOrderMark: 'true'
          encoding: UTF8
  # resource with inline JSON file format
  withJsonFormat:
    type: snowflake:StageInternal
    name: with_json_format
    properties:
      name: json_format_stage
      database: my_database
      schema: my_schema
      fileFormat:
        json:
          compression: AUTO
          dateFormat: AUTO
          timeFormat: AUTO
          timestampFormat: AUTO
          binaryFormat: HEX
          trimSpace: 'false'
          multiLine: 'false'
          nullIfs:
            - NULL
            - ""
          fileExtension: .json
          enableOctal: 'false'
          allowDuplicate: 'false'
          stripOuterArray: 'false'
          stripNullValues: 'false'
          replaceInvalidCharacters: 'false'
          skipByteOrderMark: 'false'
  # resource with inline AVRO file format
  withAvroFormat:
    type: snowflake:StageInternal
    name: with_avro_format
    properties:
      name: avro_format_stage
      database: my_database
      schema: my_schema
      fileFormat:
        avro:
          compression: GZIP
          trimSpace: 'false'
          replaceInvalidCharacters: 'false'
          nullIfs:
            - NULL
            - ""
  # resource with inline ORC file format
  withOrcFormat:
    type: snowflake:StageInternal
    name: with_orc_format
    properties:
      name: orc_format_stage
      database: my_database
      schema: my_schema
      fileFormat:
        orc:
          trimSpace: 'false'
          replaceInvalidCharacters: 'false'
          nullIfs:
            - NULL
            - ""
  # resource with inline Parquet file format
  withParquetFormat:
    type: snowflake:StageInternal
    name: with_parquet_format
    properties:
      name: parquet_format_stage
      database: my_database
      schema: my_schema
      fileFormat:
        parquet:
          compression: SNAPPY
          binaryAsText: 'true'
          useLogicalType: 'true'
          trimSpace: 'false'
          useVectorizedScanner: 'false'
          replaceInvalidCharacters: 'false'
          nullIfs:
            - NULL
            - ""
  # resource with inline XML file format
  withXmlFormat:
    type: snowflake:StageInternal
    name: with_xml_format
    properties:
      name: xml_format_stage
      database: my_database
      schema: my_schema
      fileFormat:
        xml:
          compression: AUTO
          preserveSpace: 'false'
          stripOuterElement: 'false'
          disableAutoConvert: 'false'
          replaceInvalidCharacters: 'false'
          skipByteOrderMark: 'false'
  # resource with named file format
  withNamedFormat:
    type: snowflake:StageInternal
    name: with_named_format
    properties:
      name: named_format_stage
      database: my_database
      schema: my_schema
      fileFormat:
        formatName: ${test.fullyQualifiedName}

var stageInternalResource = new Snowflake.StageInternal("stageInternalResource", new()
{
    Database = "string",
    Schema = "string",
    Comment = "string",
    Directory = new Snowflake.Inputs.StageInternalDirectoryArgs
    {
        Enable = false,
        AutoRefresh = "string",
    },
    Encryption = new Snowflake.Inputs.StageInternalEncryptionArgs
    {
        SnowflakeFull = null,
        SnowflakeSse = null,
    },
    FileFormat = new Snowflake.Inputs.StageInternalFileFormatArgs
    {
        Avro = new Snowflake.Inputs.StageInternalFileFormatAvroArgs
        {
            Compression = "string",
            NullIfs = new[]
            {
                "string",
            },
            ReplaceInvalidCharacters = "string",
            TrimSpace = "string",
        },
        Csv = new Snowflake.Inputs.StageInternalFileFormatCsvArgs
        {
            BinaryFormat = "string",
            Compression = "string",
            DateFormat = "string",
            EmptyFieldAsNull = "string",
            Encoding = "string",
            ErrorOnColumnCountMismatch = "string",
            Escape = "string",
            EscapeUnenclosedField = "string",
            FieldDelimiter = "string",
            FieldOptionallyEnclosedBy = "string",
            FileExtension = "string",
            MultiLine = "string",
            NullIfs = new[]
            {
                "string",
            },
            ParseHeader = "string",
            RecordDelimiter = "string",
            ReplaceInvalidCharacters = "string",
            SkipBlankLines = "string",
            SkipByteOrderMark = "string",
            SkipHeader = 0,
            TimeFormat = "string",
            TimestampFormat = "string",
            TrimSpace = "string",
        },
        FormatName = "string",
        Json = new Snowflake.Inputs.StageInternalFileFormatJsonArgs
        {
            AllowDuplicate = "string",
            BinaryFormat = "string",
            Compression = "string",
            DateFormat = "string",
            EnableOctal = "string",
            FileExtension = "string",
            IgnoreUtf8Errors = "string",
            MultiLine = "string",
            NullIfs = new[]
            {
                "string",
            },
            ReplaceInvalidCharacters = "string",
            SkipByteOrderMark = "string",
            StripNullValues = "string",
            StripOuterArray = "string",
            TimeFormat = "string",
            TimestampFormat = "string",
            TrimSpace = "string",
        },
        Orc = new Snowflake.Inputs.StageInternalFileFormatOrcArgs
        {
            NullIfs = new[]
            {
                "string",
            },
            ReplaceInvalidCharacters = "string",
            TrimSpace = "string",
        },
        Parquet = new Snowflake.Inputs.StageInternalFileFormatParquetArgs
        {
            BinaryAsText = "string",
            Compression = "string",
            NullIfs = new[]
            {
                "string",
            },
            ReplaceInvalidCharacters = "string",
            TrimSpace = "string",
            UseLogicalType = "string",
            UseVectorizedScanner = "string",
        },
        Xml = new Snowflake.Inputs.StageInternalFileFormatXmlArgs
        {
            Compression = "string",
            DisableAutoConvert = "string",
            IgnoreUtf8Errors = "string",
            PreserveSpace = "string",
            ReplaceInvalidCharacters = "string",
            SkipByteOrderMark = "string",
            StripOuterElement = "string",
        },
    },
    Name = "string",
});