snowflake.PostgresMirror

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

//# Prerequisites
// The role that manages the mirror needs the postgres_mirror_admin application role,
// and the SNOWFLAKE application needs USAGE on the Postgres instance.
const mirrorAdmin = new snowflake.GrantApplicationRole("mirror_admin", {
    applicationRoleName: "\"SNOWFLAKE\".\"POSTGRES_MIRROR_ADMIN\"",
    parentAccountRoleName: "my_role",
});
const instanceUsage = new snowflake.Execute("instance_usage", {
    execute: "GRANT USAGE ON POSTGRES INSTANCE \"my_instance\" TO APPLICATION SNOWFLAKE",
    revert: "SELECT 1",
});
// Only when the mirror uses a warehouse.
const warehouseUsage = new snowflake.Execute("warehouse_usage", {
    execute: "GRANT USAGE ON WAREHOUSE \"MY_WAREHOUSE\" TO APPLICATION SNOWFLAKE",
    revert: "SELECT 1",
});
// Only when the mirror writes Iceberg tables to an external volume.
const externalVolumeUsage = new snowflake.Execute("external_volume_usage", {
    execute: "GRANT USAGE ON EXTERNAL VOLUME \"MY_EXTERNAL_VOLUME\" TO APPLICATION SNOWFLAKE",
    revert: "SELECT 1",
});
//# Minimal
const basic = new snowflake.PostgresMirror("basic", {
    name: "my_mirror",
    postgresInstance: "my_instance",
    postgresDatabase: "postgres",
    targetDatabase: "MY_MIRROR_DB",
    postgresTables: [
        "public.orders",
        "public.customers",
    ],
}, {
    dependsOn: [
        mirrorAdmin,
        instanceUsage,
    ],
});
//# Complete
const complete = new snowflake.PostgresMirror("complete", {
    name: "my_complete_mirror",
    postgresInstance: "my_instance",
    postgresDatabase: "postgres",
    targetDatabase: "MY_COMPLETE_MIRROR_DB",
    postgresTables: ["public.orders"],
    postgresSchemas: ["sales"],
    refreshInterval: {
        minutes: 1,
    },
    warehouse: "MY_WAREHOUSE",
    dropTargetDatabaseOnDestroy: true,
}, {
    dependsOn: [
        mirrorAdmin,
        instanceUsage,
        warehouseUsage,
    ],
});
//# Iceberg tables on an external volume
const iceberg = new snowflake.PostgresMirror("iceberg", {
    name: "my_iceberg_mirror",
    postgresInstance: "my_instance",
    postgresDatabase: "postgres",
    targetDatabase: "MY_ICEBERG_MIRROR_DB",
    postgresTables: ["public.orders"],
    targetTableType: "ICEBERG",
    externalVolume: "MY_EXTERNAL_VOLUME",
}, {
    dependsOn: [
        mirrorAdmin,
        instanceUsage,
        externalVolumeUsage,
    ],
});

import pulumi
import pulumi_snowflake as snowflake

## Prerequisites
# The role that manages the mirror needs the postgres_mirror_admin application role,
# and the SNOWFLAKE application needs USAGE on the Postgres instance.
mirror_admin = snowflake.GrantApplicationRole("mirror_admin",
    application_role_name="\"SNOWFLAKE\".\"POSTGRES_MIRROR_ADMIN\"",
    parent_account_role_name="my_role")
instance_usage = snowflake.Execute("instance_usage",
    execute="GRANT USAGE ON POSTGRES INSTANCE \"my_instance\" TO APPLICATION SNOWFLAKE",
    revert="SELECT 1")
# Only when the mirror uses a warehouse.
warehouse_usage = snowflake.Execute("warehouse_usage",
    execute="GRANT USAGE ON WAREHOUSE \"MY_WAREHOUSE\" TO APPLICATION SNOWFLAKE",
    revert="SELECT 1")
# Only when the mirror writes Iceberg tables to an external volume.
external_volume_usage = snowflake.Execute("external_volume_usage",
    execute="GRANT USAGE ON EXTERNAL VOLUME \"MY_EXTERNAL_VOLUME\" TO APPLICATION SNOWFLAKE",
    revert="SELECT 1")
## Minimal
basic = snowflake.PostgresMirror("basic",
    name="my_mirror",
    postgres_instance="my_instance",
    postgres_database="postgres",
    target_database="MY_MIRROR_DB",
    postgres_tables=[
        "public.orders",
        "public.customers",
    ],
    opts = pulumi.ResourceOptions(depends_on=[
            mirror_admin,
            instance_usage,
        ]))
## Complete
complete = snowflake.PostgresMirror("complete",
    name="my_complete_mirror",
    postgres_instance="my_instance",
    postgres_database="postgres",
    target_database="MY_COMPLETE_MIRROR_DB",
    postgres_tables=["public.orders"],
    postgres_schemas=["sales"],
    refresh_interval={
        "minutes": 1,
    },
    warehouse="MY_WAREHOUSE",
    drop_target_database_on_destroy=True,
    opts = pulumi.ResourceOptions(depends_on=[
            mirror_admin,
            instance_usage,
            warehouse_usage,
        ]))
## Iceberg tables on an external volume
iceberg = snowflake.PostgresMirror("iceberg",
    name="my_iceberg_mirror",
    postgres_instance="my_instance",
    postgres_database="postgres",
    target_database="MY_ICEBERG_MIRROR_DB",
    postgres_tables=["public.orders"],
    target_table_type="ICEBERG",
    external_volume="MY_EXTERNAL_VOLUME",
    opts = pulumi.ResourceOptions(depends_on=[
            mirror_admin,
            instance_usage,
            external_volume_usage,
        ]))

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 {
		//# Prerequisites
		// The role that manages the mirror needs the postgres_mirror_admin application role,
		// and the SNOWFLAKE application needs USAGE on the Postgres instance.
		mirrorAdmin, err := snowflake.NewGrantApplicationRole(ctx, "mirror_admin", &snowflake.GrantApplicationRoleArgs{
			ApplicationRoleName:   pulumi.String("\"SNOWFLAKE\".\"POSTGRES_MIRROR_ADMIN\""),
			ParentAccountRoleName: pulumi.String("my_role"),
		})
		if err != nil {
			return err
		}
		instanceUsage, err := snowflake.NewExecute(ctx, "instance_usage", &snowflake.ExecuteArgs{
			Execute: pulumi.String("GRANT USAGE ON POSTGRES INSTANCE \"my_instance\" TO APPLICATION SNOWFLAKE"),
			Revert:  pulumi.String("SELECT 1"),
		})
		if err != nil {
			return err
		}
		// Only when the mirror uses a warehouse.
		warehouseUsage, err := snowflake.NewExecute(ctx, "warehouse_usage", &snowflake.ExecuteArgs{
			Execute: pulumi.String("GRANT USAGE ON WAREHOUSE \"MY_WAREHOUSE\" TO APPLICATION SNOWFLAKE"),
			Revert:  pulumi.String("SELECT 1"),
		})
		if err != nil {
			return err
		}
		// Only when the mirror writes Iceberg tables to an external volume.
		externalVolumeUsage, err := snowflake.NewExecute(ctx, "external_volume_usage", &snowflake.ExecuteArgs{
			Execute: pulumi.String("GRANT USAGE ON EXTERNAL VOLUME \"MY_EXTERNAL_VOLUME\" TO APPLICATION SNOWFLAKE"),
			Revert:  pulumi.String("SELECT 1"),
		})
		if err != nil {
			return err
		}
		//# Minimal
		_, err = snowflake.NewPostgresMirror(ctx, "basic", &snowflake.PostgresMirrorArgs{
			Name:             pulumi.String("my_mirror"),
			PostgresInstance: pulumi.String("my_instance"),
			PostgresDatabase: pulumi.String("postgres"),
			TargetDatabase:   pulumi.String("MY_MIRROR_DB"),
			PostgresTables: pulumi.StringArray{
				pulumi.String("public.orders"),
				pulumi.String("public.customers"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			mirrorAdmin,
			instanceUsage,
		}))
		if err != nil {
			return err
		}
		//# Complete
		_, err = snowflake.NewPostgresMirror(ctx, "complete", &snowflake.PostgresMirrorArgs{
			Name:             pulumi.String("my_complete_mirror"),
			PostgresInstance: pulumi.String("my_instance"),
			PostgresDatabase: pulumi.String("postgres"),
			TargetDatabase:   pulumi.String("MY_COMPLETE_MIRROR_DB"),
			PostgresTables: pulumi.StringArray{
				pulumi.String("public.orders"),
			},
			PostgresSchemas: pulumi.StringArray{
				pulumi.String("sales"),
			},
			RefreshInterval: &snowflake.PostgresMirrorRefreshIntervalArgs{
				Minutes: pulumi.Int(1),
			},
			Warehouse:                   pulumi.String("MY_WAREHOUSE"),
			DropTargetDatabaseOnDestroy: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			mirrorAdmin,
			instanceUsage,
			warehouseUsage,
		}))
		if err != nil {
			return err
		}
		//# Iceberg tables on an external volume
		_, err = snowflake.NewPostgresMirror(ctx, "iceberg", &snowflake.PostgresMirrorArgs{
			Name:             pulumi.String("my_iceberg_mirror"),
			PostgresInstance: pulumi.String("my_instance"),
			PostgresDatabase: pulumi.String("postgres"),
			TargetDatabase:   pulumi.String("MY_ICEBERG_MIRROR_DB"),
			PostgresTables: pulumi.StringArray{
				pulumi.String("public.orders"),
			},
			TargetTableType: pulumi.String("ICEBERG"),
			ExternalVolume:  pulumi.String("MY_EXTERNAL_VOLUME"),
		}, pulumi.DependsOn([]pulumi.Resource{
			mirrorAdmin,
			instanceUsage,
			externalVolumeUsage,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    //# Prerequisites
    // The role that manages the mirror needs the postgres_mirror_admin application role,
    // and the SNOWFLAKE application needs USAGE on the Postgres instance.
    var mirrorAdmin = new Snowflake.GrantApplicationRole("mirror_admin", new()
    {
        ApplicationRoleName = "\"SNOWFLAKE\".\"POSTGRES_MIRROR_ADMIN\"",
        ParentAccountRoleName = "my_role",
    });

    var instanceUsage = new Snowflake.Execute("instance_usage", new()
    {
        ExecuteSQL = "GRANT USAGE ON POSTGRES INSTANCE \"my_instance\" TO APPLICATION SNOWFLAKE",
        Revert = "SELECT 1",
    });

    // Only when the mirror uses a warehouse.
    var warehouseUsage = new Snowflake.Execute("warehouse_usage", new()
    {
        ExecuteSQL = "GRANT USAGE ON WAREHOUSE \"MY_WAREHOUSE\" TO APPLICATION SNOWFLAKE",
        Revert = "SELECT 1",
    });

    // Only when the mirror writes Iceberg tables to an external volume.
    var externalVolumeUsage = new Snowflake.Execute("external_volume_usage", new()
    {
        ExecuteSQL = "GRANT USAGE ON EXTERNAL VOLUME \"MY_EXTERNAL_VOLUME\" TO APPLICATION SNOWFLAKE",
        Revert = "SELECT 1",
    });

    //# Minimal
    var basic = new Snowflake.PostgresMirror("basic", new()
    {
        Name = "my_mirror",
        PostgresInstance = "my_instance",
        PostgresDatabase = "postgres",
        TargetDatabase = "MY_MIRROR_DB",
        PostgresTables = new[]
        {
            "public.orders",
            "public.customers",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            mirrorAdmin,
            instanceUsage,
        },
    });

    //# Complete
    var complete = new Snowflake.PostgresMirror("complete", new()
    {
        Name = "my_complete_mirror",
        PostgresInstance = "my_instance",
        PostgresDatabase = "postgres",
        TargetDatabase = "MY_COMPLETE_MIRROR_DB",
        PostgresTables = new[]
        {
            "public.orders",
        },
        PostgresSchemas = new[]
        {
            "sales",
        },
        RefreshInterval = new Snowflake.Inputs.PostgresMirrorRefreshIntervalArgs
        {
            Minutes = 1,
        },
        Warehouse = "MY_WAREHOUSE",
        DropTargetDatabaseOnDestroy = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            mirrorAdmin,
            instanceUsage,
            warehouseUsage,
        },
    });

    //# Iceberg tables on an external volume
    var iceberg = new Snowflake.PostgresMirror("iceberg", new()
    {
        Name = "my_iceberg_mirror",
        PostgresInstance = "my_instance",
        PostgresDatabase = "postgres",
        TargetDatabase = "MY_ICEBERG_MIRROR_DB",
        PostgresTables = new[]
        {
            "public.orders",
        },
        TargetTableType = "ICEBERG",
        ExternalVolume = "MY_EXTERNAL_VOLUME",
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            mirrorAdmin,
            instanceUsage,
            externalVolumeUsage,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.snowflake.GrantApplicationRole;
import com.pulumi.snowflake.GrantApplicationRoleArgs;
import com.pulumi.snowflake.Execute;
import com.pulumi.snowflake.ExecuteArgs;
import com.pulumi.snowflake.PostgresMirror;
import com.pulumi.snowflake.PostgresMirrorArgs;
import com.pulumi.snowflake.inputs.PostgresMirrorRefreshIntervalArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        //# Prerequisites
        // The role that manages the mirror needs the postgres_mirror_admin application role,
        // and the SNOWFLAKE application needs USAGE on the Postgres instance.
        var mirrorAdmin = new GrantApplicationRole("mirrorAdmin", GrantApplicationRoleArgs.builder()
            .applicationRoleName("\"SNOWFLAKE\".\"POSTGRES_MIRROR_ADMIN\"")
            .parentAccountRoleName("my_role")
            .build());

        var instanceUsage = new Execute("instanceUsage", ExecuteArgs.builder()
            .execute("GRANT USAGE ON POSTGRES INSTANCE \"my_instance\" TO APPLICATION SNOWFLAKE")
            .revert("SELECT 1")
            .build());

        // Only when the mirror uses a warehouse.
        var warehouseUsage = new Execute("warehouseUsage", ExecuteArgs.builder()
            .execute("GRANT USAGE ON WAREHOUSE \"MY_WAREHOUSE\" TO APPLICATION SNOWFLAKE")
            .revert("SELECT 1")
            .build());

        // Only when the mirror writes Iceberg tables to an external volume.
        var externalVolumeUsage = new Execute("externalVolumeUsage", ExecuteArgs.builder()
            .execute("GRANT USAGE ON EXTERNAL VOLUME \"MY_EXTERNAL_VOLUME\" TO APPLICATION SNOWFLAKE")
            .revert("SELECT 1")
            .build());

        //# Minimal
        var basic = new PostgresMirror("basic", PostgresMirrorArgs.builder()
            .name("my_mirror")
            .postgresInstance("my_instance")
            .postgresDatabase("postgres")
            .targetDatabase("MY_MIRROR_DB")
            .postgresTables(            
                "public.orders",
                "public.customers")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    mirrorAdmin,
                    instanceUsage)
                .build());

        //# Complete
        var complete = new PostgresMirror("complete", PostgresMirrorArgs.builder()
            .name("my_complete_mirror")
            .postgresInstance("my_instance")
            .postgresDatabase("postgres")
            .targetDatabase("MY_COMPLETE_MIRROR_DB")
            .postgresTables("public.orders")
            .postgresSchemas("sales")
            .refreshInterval(PostgresMirrorRefreshIntervalArgs.builder()
                .minutes(1)
                .build())
            .warehouse("MY_WAREHOUSE")
            .dropTargetDatabaseOnDestroy(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    mirrorAdmin,
                    instanceUsage,
                    warehouseUsage)
                .build());

        //# Iceberg tables on an external volume
        var iceberg = new PostgresMirror("iceberg", PostgresMirrorArgs.builder()
            .name("my_iceberg_mirror")
            .postgresInstance("my_instance")
            .postgresDatabase("postgres")
            .targetDatabase("MY_ICEBERG_MIRROR_DB")
            .postgresTables("public.orders")
            .targetTableType("ICEBERG")
            .externalVolume("MY_EXTERNAL_VOLUME")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    mirrorAdmin,
                    instanceUsage,
                    externalVolumeUsage)
                .build());

    }
}

resources:
  ## Prerequisites
  # The role that manages the mirror needs the postgres_mirror_admin application role,
  # and the SNOWFLAKE application needs USAGE on the Postgres instance.
  mirrorAdmin:
    type: snowflake:GrantApplicationRole
    name: mirror_admin
    properties:
      applicationRoleName: '"SNOWFLAKE"."POSTGRES_MIRROR_ADMIN"'
      parentAccountRoleName: my_role
  instanceUsage:
    type: snowflake:Execute
    name: instance_usage
    properties:
      execute: GRANT USAGE ON POSTGRES INSTANCE "my_instance" TO APPLICATION SNOWFLAKE
      revert: SELECT 1
  # Only when the mirror uses a warehouse.
  warehouseUsage:
    type: snowflake:Execute
    name: warehouse_usage
    properties:
      execute: GRANT USAGE ON WAREHOUSE "MY_WAREHOUSE" TO APPLICATION SNOWFLAKE
      revert: SELECT 1
  # Only when the mirror writes Iceberg tables to an external volume.
  externalVolumeUsage:
    type: snowflake:Execute
    name: external_volume_usage
    properties:
      execute: GRANT USAGE ON EXTERNAL VOLUME "MY_EXTERNAL_VOLUME" TO APPLICATION SNOWFLAKE
      revert: SELECT 1
  ## Minimal
  basic:
    type: snowflake:PostgresMirror
    properties:
      name: my_mirror
      postgresInstance: my_instance
      postgresDatabase: postgres
      targetDatabase: MY_MIRROR_DB
      postgresTables:
        - public.orders
        - public.customers
    options:
      dependsOn:
        - ${mirrorAdmin}
        - ${instanceUsage}
  ## Complete
  complete:
    type: snowflake:PostgresMirror
    properties:
      name: my_complete_mirror
      postgresInstance: my_instance
      postgresDatabase: postgres
      targetDatabase: MY_COMPLETE_MIRROR_DB
      postgresTables:
        - public.orders
      postgresSchemas:
        - sales
      refreshInterval:
        minutes: 1
      warehouse: MY_WAREHOUSE
      dropTargetDatabaseOnDestroy: true
    options:
      dependsOn:
        - ${mirrorAdmin}
        - ${instanceUsage}
        - ${warehouseUsage}
  ## Iceberg tables on an external volume
  iceberg:
    type: snowflake:PostgresMirror
    properties:
      name: my_iceberg_mirror
      postgresInstance: my_instance
      postgresDatabase: postgres
      targetDatabase: MY_ICEBERG_MIRROR_DB
      postgresTables:
        - public.orders
      targetTableType: ICEBERG
      externalVolume: MY_EXTERNAL_VOLUME
    options:
      dependsOn:
        - ${mirrorAdmin}
        - ${instanceUsage}
        - ${externalVolumeUsage}

terraform {
  required_providers {
    snowflake = {
      source = "pulumi/snowflake"
    }
  }
}

## Prerequisites
# The role that manages the mirror needs the postgres_mirror_admin application role,
# and the SNOWFLAKE application needs USAGE on the Postgres instance.
resource "snowflake_grant_application_role" "mirror_admin" {
  lifecycle {
    create_before_destroy = true
  }
  application_role_name    = "\"SNOWFLAKE\".\"POSTGRES_MIRROR_ADMIN\""
  parent_account_role_name = "my_role"
}
resource "snowflake_execute" "instance_usage" {
  lifecycle {
    create_before_destroy = true
  }
  execute = "GRANT USAGE ON POSTGRES INSTANCE \"my_instance\" TO APPLICATION SNOWFLAKE"
  revert  = "SELECT 1"
}
# Only when the mirror uses a warehouse.
resource "snowflake_execute" "warehouse_usage" {
  lifecycle {
    create_before_destroy = true
  }
  execute = "GRANT USAGE ON WAREHOUSE \"MY_WAREHOUSE\" TO APPLICATION SNOWFLAKE"
  revert  = "SELECT 1"
}
# Only when the mirror writes Iceberg tables to an external volume.
resource "snowflake_execute" "external_volume_usage" {
  lifecycle {
    create_before_destroy = true
  }
  execute = "GRANT USAGE ON EXTERNAL VOLUME \"MY_EXTERNAL_VOLUME\" TO APPLICATION SNOWFLAKE"
  revert  = "SELECT 1"
}
## Minimal
resource "snowflake_postgres_mirror" "basic" {
  depends_on = [snowflake_grant_application_role.mirror_admin, snowflake_execute.instance_usage]
  lifecycle {
    create_before_destroy = true
  }
  name              = "my_mirror"
  postgres_instance = "my_instance"
  postgres_database = "postgres"
  target_database   = "MY_MIRROR_DB"
  postgres_tables   = ["public.orders", "public.customers"]
}
## Complete
resource "snowflake_postgres_mirror" "complete" {
  depends_on = [snowflake_grant_application_role.mirror_admin, snowflake_execute.instance_usage, snowflake_execute.warehouse_usage]
  lifecycle {
    create_before_destroy = true
  }
  name              = "my_complete_mirror"
  postgres_instance = "my_instance"
  postgres_database = "postgres"
  target_database   = "MY_COMPLETE_MIRROR_DB"
  postgres_tables   = ["public.orders"]
  postgres_schemas  = ["sales"]
  refresh_interval {
    minutes = 1
  }
  warehouse                       = "MY_WAREHOUSE"
  drop_target_database_on_destroy = true
}
## Iceberg tables on an external volume
resource "snowflake_postgres_mirror" "iceberg" {
  depends_on = [snowflake_grant_application_role.mirror_admin, snowflake_execute.instance_usage, snowflake_execute.external_volume_usage]
  lifecycle {
    create_before_destroy = true
  }
  name              = "my_iceberg_mirror"
  postgres_instance = "my_instance"
  postgres_database = "postgres"
  target_database   = "MY_ICEBERG_MIRROR_DB"
  postgres_tables   = ["public.orders"]
  target_table_type = "ICEBERG"
  external_volume   = "MY_EXTERNAL_VOLUME"
}

var postgresMirrorResource = new Snowflake.PostgresMirror("postgresMirrorResource", new()
{
    PostgresDatabase = "string",
    PostgresInstance = "string",
    TargetDatabase = "string",
    DropTargetDatabaseOnDestroy = false,
    ExternalVolume = "string",
    Name = "string",
    PostgresSchemas = new[]
    {
        "string",
    },
    PostgresTables = new[]
    {
        "string",
    },
    RefreshInterval = new Snowflake.Inputs.PostgresMirrorRefreshIntervalArgs
    {
        Hours = 0,
        Minutes = 0,
        Seconds = 0,
    },
    TargetTableType = "string",
    Warehouse = "string",
});

example, err := snowflake.NewPostgresMirror(ctx, "postgresMirrorResource", &snowflake.PostgresMirrorArgs{
	PostgresDatabase:            pulumi.String("string"),
	PostgresInstance:            pulumi.String("string"),
	TargetDatabase:              pulumi.String("string"),
	DropTargetDatabaseOnDestroy: pulumi.Bool(false),
	ExternalVolume:              pulumi.String("string"),
	Name:                        pulumi.String("string"),
	PostgresSchemas: pulumi.StringArray{
		pulumi.String("string"),
	},
	PostgresTables: pulumi.StringArray{
		pulumi.String("string"),
	},
	RefreshInterval: &snowflake.PostgresMirrorRefreshIntervalArgs{
		Hours:   pulumi.Int(0),
		Minutes: pulumi.Int(0),
		Seconds: pulumi.Int(0),
	},
	TargetTableType: pulumi.String("string"),
	Warehouse:       pulumi.String("string"),
})

resource "snowflake_postgres_mirror" "postgresMirrorResource" {
  lifecycle {
    create_before_destroy = true
  }
  postgres_database               = "string"
  postgres_instance               = "string"
  target_database                 = "string"
  drop_target_database_on_destroy = false
  external_volume                 = "string"
  name                            = "string"
  postgres_schemas                = ["string"]
  postgres_tables                 = ["string"]
  refresh_interval = {
    hours   = 0
    minutes = 0
    seconds = 0
  }
  target_table_type = "string"
  warehouse         = "string"
}

var postgresMirrorResource = new PostgresMirror("postgresMirrorResource", PostgresMirrorArgs.builder()
    .postgresDatabase("string")
    .postgresInstance("string")
    .targetDatabase("string")
    .dropTargetDatabaseOnDestroy(false)
    .externalVolume("string")
    .name("string")
    .postgresSchemas("string")
    .postgresTables("string")
    .refreshInterval(PostgresMirrorRefreshIntervalArgs.builder()
        .hours(0)
        .minutes(0)
        .seconds(0)
        .build())
    .targetTableType("string")
    .warehouse("string")
    .build());

postgres_mirror_resource = snowflake.PostgresMirror("postgresMirrorResource",
    postgres_database="string",
    postgres_instance="string",
    target_database="string",
    drop_target_database_on_destroy=False,
    external_volume="string",
    name="string",
    postgres_schemas=["string"],
    postgres_tables=["string"],
    refresh_interval={
        "hours": 0,
        "minutes": 0,
        "seconds": 0,
    },
    target_table_type="string",
    warehouse="string")

const postgresMirrorResource = new snowflake.PostgresMirror("postgresMirrorResource", {
    postgresDatabase: "string",
    postgresInstance: "string",
    targetDatabase: "string",
    dropTargetDatabaseOnDestroy: false,
    externalVolume: "string",
    name: "string",
    postgresSchemas: ["string"],
    postgresTables: ["string"],
    refreshInterval: {
        hours: 0,
        minutes: 0,
        seconds: 0,
    },
    targetTableType: "string",
    warehouse: "string",
});

type: snowflake:PostgresMirror
properties:
    dropTargetDatabaseOnDestroy: false
    externalVolume: string
    name: string
    postgresDatabase: string
    postgresInstance: string
    postgresSchemas:
        - string
    postgresTables:
        - string
    refreshInterval:
        hours: 0
        minutes: 0
        seconds: 0
    targetDatabase: string
    targetTableType: string
    warehouse: string