formal.NativeUserV3

import * as pulumi from "@pulumi/pulumi";
import * as formal from "@formalco/pulumi";

const config = new pulumi.Config();
const analyticsAdminPassword = config.require("analyticsAdminPassword");
const db = new formal.Resource("db", {
    name: "analytics-postgres",
    hostname: "analytics.internal",
    technology: "postgres",
    port: 5432,
    nativeUsersV3Enabled: true,
});
// Username and password, read from an environment variable on the connector.
const basic = new formal.NativeUserV3("basic", {
    basic: {
        password: {
            environmentVariable: "ANALYTICS_ADMIN_PASSWORD",
        },
        username: "app_admin",
    },
    resourceId: db.id,
    label: "admin",
});
// Username and password, with the password passed as a write-only value so it
// never lands in Terraform state. Increment literal_wo_version to rotate it.
const basicWriteOnly = new formal.NativeUserV3("basic_write_only", {
    basic: {
        password: {
            literalWo: analyticsAdminPassword,
            literalWoVersion: 1,
        },
        username: "app_admin",
    },
    resourceId: db.id,
    label: "admin-write-only",
});
// AWS IAM, inheriting the role from the connector's environment.
const awsIam = new formal.NativeUserV3("aws_iam", {
    awsIam: {
        username: "app_iam",
    },
    resourceId: db.id,
    label: "iam",
});
const api = new formal.Resource("api", {
    name: "billing-api",
    hostname: "billing.internal",
    technology: "http",
    port: 443,
    nativeUsersV3Enabled: true,
});
const bearerToken = new formal.NativeUserV3("bearer_token", {
    httpBearer: {
        token: {
            environmentVariable: "BILLING_API_TOKEN",
        },
        header: "Authorization",
    },
    resourceId: api.id,
    label: "service-account",
});
// Credentials resolved at connection time by a hook running on the connector,
// for example to mint short-lived credentials from a secrets manager.
const fromHook = new formal.NativeUserV3("from_hook", {
    hook: {
        outputType: "basic",
        allowlistedEnvVariables: [
            "FORMAL_ENV_USER",
            "FORMAL_ENV_PASSWORD",
        ],
        code: `export default async function (_input, env) {
  return {
    username: env.FORMAL_ENV_USER,
    password: env.FORMAL_ENV_PASSWORD,
  };
}
`,
    },
    resourceId: db.id,
    label: "dynamic",
});

import pulumi
import pulumi_formal as formal

config = pulumi.Config()
analytics_admin_password = config.require("analyticsAdminPassword")
db = formal.Resource("db",
    name="analytics-postgres",
    hostname="analytics.internal",
    technology="postgres",
    port=5432,
    native_users_v3_enabled=True)
# Username and password, read from an environment variable on the connector.
basic = formal.NativeUserV3("basic",
    basic={
        "password": {
            "environment_variable": "ANALYTICS_ADMIN_PASSWORD",
        },
        "username": "app_admin",
    },
    resource_id=db.id,
    label="admin")
# Username and password, with the password passed as a write-only value so it
# never lands in Terraform state. Increment literal_wo_version to rotate it.
basic_write_only = formal.NativeUserV3("basic_write_only",
    basic={
        "password": {
            "literal_wo": analytics_admin_password,
            "literal_wo_version": 1,
        },
        "username": "app_admin",
    },
    resource_id=db.id,
    label="admin-write-only")
# AWS IAM, inheriting the role from the connector's environment.
aws_iam = formal.NativeUserV3("aws_iam",
    aws_iam={
        "username": "app_iam",
    },
    resource_id=db.id,
    label="iam")
api = formal.Resource("api",
    name="billing-api",
    hostname="billing.internal",
    technology="http",
    port=443,
    native_users_v3_enabled=True)
bearer_token = formal.NativeUserV3("bearer_token",
    http_bearer={
        "token": {
            "environment_variable": "BILLING_API_TOKEN",
        },
        "header": "Authorization",
    },
    resource_id=api.id,
    label="service-account")
# Credentials resolved at connection time by a hook running on the connector,
# for example to mint short-lived credentials from a secrets manager.
from_hook = formal.NativeUserV3("from_hook",
    hook={
        "output_type": "basic",
        "allowlisted_env_variables": [
            "FORMAL_ENV_USER",
            "FORMAL_ENV_PASSWORD",
        ],
        "code": """export default async function (_input, env) {
  return {
    username: env.FORMAL_ENV_USER,
    password: env.FORMAL_ENV_PASSWORD,
  };
}
""",
    },
    resource_id=db.id,
    label="dynamic")

package main

import (
	"github.com/formalco/pulumi-formal/sdk/go/formal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		analyticsAdminPassword := cfg.Require("analyticsAdminPassword")
		db, err := formal.NewResource(ctx, "db", &formal.ResourceArgs{
			Name:                 pulumi.String("analytics-postgres"),
			Hostname:             pulumi.String("analytics.internal"),
			Technology:           pulumi.String("postgres"),
			Port:                 pulumi.Int(5432),
			NativeUsersV3Enabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// Username and password, read from an environment variable on the connector.
		_, err = formal.NewNativeUserV3(ctx, "basic", &formal.NativeUserV3Args{
			Basic: &formal.NativeUserV3BasicArgs{
				Password: &formal.NativeUserV3BasicPasswordArgs{
					EnvironmentVariable: pulumi.String("ANALYTICS_ADMIN_PASSWORD"),
				},
				Username: pulumi.String("app_admin"),
			},
			ResourceId: db.ID(),
			Label:      pulumi.String("admin"),
		})
		if err != nil {
			return err
		}
		// Username and password, with the password passed as a write-only value so it
		// never lands in Terraform state. Increment literal_wo_version to rotate it.
		_, err = formal.NewNativeUserV3(ctx, "basic_write_only", &formal.NativeUserV3Args{
			Basic: &formal.NativeUserV3BasicArgs{
				Password: &formal.NativeUserV3BasicPasswordArgs{
					LiteralWo:        pulumi.String(pulumi.String(analyticsAdminPassword)),
					LiteralWoVersion: pulumi.Int(1),
				},
				Username: pulumi.String("app_admin"),
			},
			ResourceId: db.ID(),
			Label:      pulumi.String("admin-write-only"),
		})
		if err != nil {
			return err
		}
		// AWS IAM, inheriting the role from the connector's environment.
		_, err = formal.NewNativeUserV3(ctx, "aws_iam", &formal.NativeUserV3Args{
			AwsIam: &formal.NativeUserV3AwsIamArgs{
				Username: pulumi.String("app_iam"),
			},
			ResourceId: db.ID(),
			Label:      pulumi.String("iam"),
		})
		if err != nil {
			return err
		}
		api, err := formal.NewResource(ctx, "api", &formal.ResourceArgs{
			Name:                 pulumi.String("billing-api"),
			Hostname:             pulumi.String("billing.internal"),
			Technology:           pulumi.String("http"),
			Port:                 pulumi.Int(443),
			NativeUsersV3Enabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = formal.NewNativeUserV3(ctx, "bearer_token", &formal.NativeUserV3Args{
			HttpBearer: &formal.NativeUserV3HttpBearerArgs{
				Token: &formal.NativeUserV3HttpBearerTokenArgs{
					EnvironmentVariable: pulumi.String("BILLING_API_TOKEN"),
				},
				Header: pulumi.String("Authorization"),
			},
			ResourceId: api.ID(),
			Label:      pulumi.String("service-account"),
		})
		if err != nil {
			return err
		}
		// Credentials resolved at connection time by a hook running on the connector,
		// for example to mint short-lived credentials from a secrets manager.
		_, err = formal.NewNativeUserV3(ctx, "from_hook", &formal.NativeUserV3Args{
			Hook: &formal.NativeUserV3HookArgs{
				OutputType: pulumi.String("basic"),
				AllowlistedEnvVariables: pulumi.StringArray{
					pulumi.String("FORMAL_ENV_USER"),
					pulumi.String("FORMAL_ENV_PASSWORD"),
				},
				Code: pulumi.String(`export default async function (_input, env) {
  return {
    username: env.FORMAL_ENV_USER,
    password: env.FORMAL_ENV_PASSWORD,
  };
}
`),
			},
			ResourceId: db.ID(),
			Label:      pulumi.String("dynamic"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var analyticsAdminPassword = config.Require("analyticsAdminPassword");
    var db = new Pulumi.Resource("db", new()
    {
        Name = "analytics-postgres",
        Hostname = "analytics.internal",
        Technology = "postgres",
        Port = 5432,
        NativeUsersV3Enabled = true,
    });

    // Username and password, read from an environment variable on the connector.
    var basic = new Pulumi.NativeUserV3("basic", new()
    {
        Basic = new Pulumi.Inputs.NativeUserV3BasicArgs
        {
            Password = new Pulumi.Inputs.NativeUserV3BasicPasswordArgs
            {
                EnvironmentVariable = "ANALYTICS_ADMIN_PASSWORD",
            },
            Username = "app_admin",
        },
        ResourceId = db.Id,
        Label = "admin",
    });

    // Username and password, with the password passed as a write-only value so it
    // never lands in Terraform state. Increment literal_wo_version to rotate it.
    var basicWriteOnly = new Pulumi.NativeUserV3("basic_write_only", new()
    {
        Basic = new Pulumi.Inputs.NativeUserV3BasicArgs
        {
            Password = new Pulumi.Inputs.NativeUserV3BasicPasswordArgs
            {
                LiteralWo = analyticsAdminPassword,
                LiteralWoVersion = 1,
            },
            Username = "app_admin",
        },
        ResourceId = db.Id,
        Label = "admin-write-only",
    });

    // AWS IAM, inheriting the role from the connector's environment.
    var awsIam = new Pulumi.NativeUserV3("aws_iam", new()
    {
        AwsIam = new Pulumi.Inputs.NativeUserV3AwsIamArgs
        {
            Username = "app_iam",
        },
        ResourceId = db.Id,
        Label = "iam",
    });

    var api = new Pulumi.Resource("api", new()
    {
        Name = "billing-api",
        Hostname = "billing.internal",
        Technology = "http",
        Port = 443,
        NativeUsersV3Enabled = true,
    });

    var bearerToken = new Pulumi.NativeUserV3("bearer_token", new()
    {
        HttpBearer = new Pulumi.Inputs.NativeUserV3HttpBearerArgs
        {
            Token = new Pulumi.Inputs.NativeUserV3HttpBearerTokenArgs
            {
                EnvironmentVariable = "BILLING_API_TOKEN",
            },
            Header = "Authorization",
        },
        ResourceId = api.Id,
        Label = "service-account",
    });

    // Credentials resolved at connection time by a hook running on the connector,
    // for example to mint short-lived credentials from a secrets manager.
    var fromHook = new Pulumi.NativeUserV3("from_hook", new()
    {
        Hook = new Pulumi.Inputs.NativeUserV3HookArgs
        {
            OutputType = "basic",
            AllowlistedEnvVariables = new[]
            {
                "FORMAL_ENV_USER",
                "FORMAL_ENV_PASSWORD",
            },
            Code = @"export default async function (_input, env) {
  return {
    username: env.FORMAL_ENV_USER,
    password: env.FORMAL_ENV_PASSWORD,
  };
}
",
        },
        ResourceId = db.Id,
        Label = "dynamic",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.formal.Resource;
import com.pulumi.formal.ResourceArgs;
import com.pulumi.formal.NativeUserV3;
import com.pulumi.formal.NativeUserV3Args;
import com.pulumi.formal.inputs.NativeUserV3BasicArgs;
import com.pulumi.formal.inputs.NativeUserV3BasicPasswordArgs;
import com.pulumi.formal.inputs.NativeUserV3AwsIamArgs;
import com.pulumi.formal.inputs.NativeUserV3HttpBearerArgs;
import com.pulumi.formal.inputs.NativeUserV3HttpBearerTokenArgs;
import com.pulumi.formal.inputs.NativeUserV3HookArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        final var config = ctx.config();
        final var analyticsAdminPassword = config.require("analyticsAdminPassword");
        var db = new Resource("db", ResourceArgs.builder()
            .name("analytics-postgres")
            .hostname("analytics.internal")
            .technology("postgres")
            .port(5432)
            .nativeUsersV3Enabled(true)
            .build());

        // Username and password, read from an environment variable on the connector.
        var basic = new NativeUserV3("basic", NativeUserV3Args.builder()
            .basic(NativeUserV3BasicArgs.builder()
                .password(NativeUserV3BasicPasswordArgs.builder()
                    .environmentVariable("ANALYTICS_ADMIN_PASSWORD")
                    .build())
                .username("app_admin")
                .build())
            .resourceId(db.id())
            .label("admin")
            .build());

        // Username and password, with the password passed as a write-only value so it
        // never lands in Terraform state. Increment literal_wo_version to rotate it.
        var basicWriteOnly = new NativeUserV3("basicWriteOnly", NativeUserV3Args.builder()
            .basic(NativeUserV3BasicArgs.builder()
                .password(NativeUserV3BasicPasswordArgs.builder()
                    .literalWo(analyticsAdminPassword)
                    .literalWoVersion(1)
                    .build())
                .username("app_admin")
                .build())
            .resourceId(db.id())
            .label("admin-write-only")
            .build());

        // AWS IAM, inheriting the role from the connector's environment.
        var awsIam = new NativeUserV3("awsIam", NativeUserV3Args.builder()
            .awsIam(NativeUserV3AwsIamArgs.builder()
                .username("app_iam")
                .build())
            .resourceId(db.id())
            .label("iam")
            .build());

        var api = new Resource("api", ResourceArgs.builder()
            .name("billing-api")
            .hostname("billing.internal")
            .technology("http")
            .port(443)
            .nativeUsersV3Enabled(true)
            .build());

        var bearerToken = new NativeUserV3("bearerToken", NativeUserV3Args.builder()
            .httpBearer(NativeUserV3HttpBearerArgs.builder()
                .token(NativeUserV3HttpBearerTokenArgs.builder()
                    .environmentVariable("BILLING_API_TOKEN")
                    .build())
                .header("Authorization")
                .build())
            .resourceId(api.id())
            .label("service-account")
            .build());

        // Credentials resolved at connection time by a hook running on the connector,
        // for example to mint short-lived credentials from a secrets manager.
        var fromHook = new NativeUserV3("fromHook", NativeUserV3Args.builder()
            .hook(NativeUserV3HookArgs.builder()
                .outputType("basic")
                .allowlistedEnvVariables(                
                    "FORMAL_ENV_USER",
                    "FORMAL_ENV_PASSWORD")
                .code("""
export default async function (_input, env) {
  return {
    username: env.FORMAL_ENV_USER,
    password: env.FORMAL_ENV_PASSWORD,
  };
}
                """)
                .build())
            .resourceId(db.id())
            .label("dynamic")
            .build());

    }
}

configuration:
  analyticsAdminPassword:
    type: string
resources:
  db:
    type: formal:Resource
    properties:
      name: analytics-postgres
      hostname: analytics.internal
      technology: postgres
      port: 5432
      nativeUsersV3Enabled: true
  # Username and password, read from an environment variable on the connector.
  basic:
    type: formal:NativeUserV3
    properties:
      basic:
        password:
          environmentVariable: ANALYTICS_ADMIN_PASSWORD
        username: app_admin
      resourceId: ${db.id}
      label: admin
  # Username and password, with the password passed as a write-only value so it
  # never lands in Terraform state. Increment literal_wo_version to rotate it.
  basicWriteOnly:
    type: formal:NativeUserV3
    name: basic_write_only
    properties:
      basic:
        password:
          literalWo: ${analyticsAdminPassword}
          literalWoVersion: 1
        username: app_admin
      resourceId: ${db.id}
      label: admin-write-only
  # AWS IAM, inheriting the role from the connector's environment.
  awsIam:
    type: formal:NativeUserV3
    name: aws_iam
    properties:
      awsIam:
        username: app_iam
      resourceId: ${db.id}
      label: iam
  api:
    type: formal:Resource
    properties:
      name: billing-api
      hostname: billing.internal
      technology: http
      port: 443
      nativeUsersV3Enabled: true
  bearerToken:
    type: formal:NativeUserV3
    name: bearer_token
    properties:
      httpBearer:
        token:
          environmentVariable: BILLING_API_TOKEN
        header: Authorization
      resourceId: ${api.id}
      label: service-account
  # Credentials resolved at connection time by a hook running on the connector,
  # for example to mint short-lived credentials from a secrets manager.
  fromHook:
    type: formal:NativeUserV3
    name: from_hook
    properties:
      hook:
        outputType: basic
        allowlistedEnvVariables:
          - FORMAL_ENV_USER
          - FORMAL_ENV_PASSWORD
        code: |
          export default async function (_input, env) {
            return {
              username: env.FORMAL_ENV_USER,
              password: env.FORMAL_ENV_PASSWORD,
            };
          }
      resourceId: ${db.id}
      label: dynamic

pulumi {
  required_providers {
    formal = {
      source = "pulumi/formal"
    }
  }
}

resource "formal_resource" "db" {
  name                    = "analytics-postgres"
  hostname                = "analytics.internal"
  technology              = "postgres"
  port                    = 5432
  native_users_v3_enabled = true
}
# Username and password, read from an environment variable on the connector.
resource "formal_nativeuserv3" "basic" {
  basic = {
    password = {
      environment_variable = "ANALYTICS_ADMIN_PASSWORD"
    }
    username = "app_admin"
  }
  resource_id = formal_resource.db.id
  label       = "admin"
}
# Username and password, with the password passed as a write-only value so it
# never lands in Terraform state. Increment literal_wo_version to rotate it.
resource "formal_nativeuserv3" "basic_write_only" {
  basic = {
    password = {
      literal_wo         = var.analyticsAdminPassword
      literal_wo_version = 1
    }
    username = "app_admin"
  }
  resource_id = formal_resource.db.id
  label       = "admin-write-only"
}
# AWS IAM, inheriting the role from the connector's environment.
resource "formal_nativeuserv3" "aws_iam" {
  aws_iam = {
    username = "app_iam"
  }
  resource_id = formal_resource.db.id
  label       = "iam"
}
resource "formal_resource" "api" {
  name                    = "billing-api"
  hostname                = "billing.internal"
  technology              = "http"
  port                    = 443
  native_users_v3_enabled = true
}
resource "formal_nativeuserv3" "bearer_token" {
  http_bearer = {
    token = {
      environment_variable = "BILLING_API_TOKEN"
    }
    header = "Authorization"
  }
  resource_id = formal_resource.api.id
  label       = "service-account"
}
# Credentials resolved at connection time by a hook running on the connector,
# for example to mint short-lived credentials from a secrets manager.
resource "formal_nativeuserv3" "from_hook" {
  hook = {
    output_type               = "basic"
    allowlisted_env_variables = ["FORMAL_ENV_USER", "FORMAL_ENV_PASSWORD"]
    code                      = "export default async function (_input, env) {\n  return {\n    username: env.FORMAL_ENV_USER,\n    password: env.FORMAL_ENV_PASSWORD,\n  };\n}\n"
  }
  resource_id = formal_resource.db.id
  label       = "dynamic"
}
variable "analyticsAdminPassword" {
  type = string
}

var nativeUserV3Resource = new Pulumi.NativeUserV3("nativeUserV3Resource", new()
{
    Label = "string",
    ResourceId = "string",
    GcpIam = new Pulumi.Inputs.NativeUserV3GcpIamArgs
    {
        Username = "string",
    },
    HttpBearer = new Pulumi.Inputs.NativeUserV3HttpBearerArgs
    {
        Header = "string",
        Token = new Pulumi.Inputs.NativeUserV3HttpBearerTokenArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
    },
    AwsIam = new Pulumi.Inputs.NativeUserV3AwsIamArgs
    {
        Username = "string",
    },
    Hook = new Pulumi.Inputs.NativeUserV3HookArgs
    {
        Code = "string",
        OutputType = "string",
        AllowlistedEnvVariables = new[]
        {
            "string",
        },
        AllowlistedNetworkHosts = new[]
        {
            "string",
        },
    },
    HttpApiKeyHeader = new Pulumi.Inputs.NativeUserV3HttpApiKeyHeaderArgs
    {
        Key = "string",
        Value = new Pulumi.Inputs.NativeUserV3HttpApiKeyHeaderValueArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
    },
    HttpApiKeyQuery = new Pulumi.Inputs.NativeUserV3HttpApiKeyQueryArgs
    {
        Key = "string",
        Value = new Pulumi.Inputs.NativeUserV3HttpApiKeyQueryValueArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
    },
    HttpBasic = new Pulumi.Inputs.NativeUserV3HttpBasicArgs
    {
        Header = "string",
        Password = new Pulumi.Inputs.NativeUserV3HttpBasicPasswordArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
        Username = "string",
    },
    Basic = new Pulumi.Inputs.NativeUserV3BasicArgs
    {
        Password = new Pulumi.Inputs.NativeUserV3BasicPasswordArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
        Username = "string",
    },
    KubernetesInline = new Pulumi.Inputs.NativeUserV3KubernetesInlineArgs
    {
        Kubeconfig = new Pulumi.Inputs.NativeUserV3KubernetesInlineKubeconfigArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
    },
    KubernetesPath = new Pulumi.Inputs.NativeUserV3KubernetesPathArgs
    {
        KubeconfigPath = new Pulumi.Inputs.NativeUserV3KubernetesPathKubeconfigPathArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
    },
    AzureIam = new Pulumi.Inputs.NativeUserV3AzureIamArgs
    {
        Username = "string",
    },
    AwsIamRole = new Pulumi.Inputs.NativeUserV3AwsIamRoleArgs
    {
        Role = "string",
        Username = "string",
    },
    SnowflakeKey = new Pulumi.Inputs.NativeUserV3SnowflakeKeyArgs
    {
        Key = new Pulumi.Inputs.NativeUserV3SnowflakeKeyKeyArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
        Username = "string",
    },
    SshKey = new Pulumi.Inputs.NativeUserV3SshKeyArgs
    {
        Key = new Pulumi.Inputs.NativeUserV3SshKeyKeyArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
        Username = "string",
        Certificate = new Pulumi.Inputs.NativeUserV3SshKeyCertificateArgs
        {
            EnvironmentVariable = "string",
            Literal = "string",
            LiteralWo = "string",
            LiteralWoVersion = 0,
        },
    },
    TerminationProtection = false,
});

example, err := formal.NewNativeUserV3(ctx, "nativeUserV3Resource", &formal.NativeUserV3Args{
	Label:      pulumi.String("string"),
	ResourceId: pulumi.String("string"),
	GcpIam: &formal.NativeUserV3GcpIamArgs{
		Username: pulumi.String("string"),
	},
	HttpBearer: &formal.NativeUserV3HttpBearerArgs{
		Header: pulumi.String("string"),
		Token: &formal.NativeUserV3HttpBearerTokenArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
	},
	AwsIam: &formal.NativeUserV3AwsIamArgs{
		Username: pulumi.String("string"),
	},
	Hook: &formal.NativeUserV3HookArgs{
		Code:       pulumi.String("string"),
		OutputType: pulumi.String("string"),
		AllowlistedEnvVariables: pulumi.StringArray{
			pulumi.String("string"),
		},
		AllowlistedNetworkHosts: pulumi.StringArray{
			pulumi.String("string"),
		},
	},
	HttpApiKeyHeader: &formal.NativeUserV3HttpApiKeyHeaderArgs{
		Key: pulumi.String("string"),
		Value: &formal.NativeUserV3HttpApiKeyHeaderValueArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
	},
	HttpApiKeyQuery: &formal.NativeUserV3HttpApiKeyQueryArgs{
		Key: pulumi.String("string"),
		Value: &formal.NativeUserV3HttpApiKeyQueryValueArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
	},
	HttpBasic: &formal.NativeUserV3HttpBasicArgs{
		Header: pulumi.String("string"),
		Password: &formal.NativeUserV3HttpBasicPasswordArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
		Username: pulumi.String("string"),
	},
	Basic: &formal.NativeUserV3BasicArgs{
		Password: &formal.NativeUserV3BasicPasswordArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
		Username: pulumi.String("string"),
	},
	KubernetesInline: &formal.NativeUserV3KubernetesInlineArgs{
		Kubeconfig: &formal.NativeUserV3KubernetesInlineKubeconfigArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
	},
	KubernetesPath: &formal.NativeUserV3KubernetesPathArgs{
		KubeconfigPath: &formal.NativeUserV3KubernetesPathKubeconfigPathArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
	},
	AzureIam: &formal.NativeUserV3AzureIamArgs{
		Username: pulumi.String("string"),
	},
	AwsIamRole: &formal.NativeUserV3AwsIamRoleArgs{
		Role:     pulumi.String("string"),
		Username: pulumi.String("string"),
	},
	SnowflakeKey: &formal.NativeUserV3SnowflakeKeyArgs{
		Key: &formal.NativeUserV3SnowflakeKeyKeyArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
		Username: pulumi.String("string"),
	},
	SshKey: &formal.NativeUserV3SshKeyArgs{
		Key: &formal.NativeUserV3SshKeyKeyArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
		Username: pulumi.String("string"),
		Certificate: &formal.NativeUserV3SshKeyCertificateArgs{
			EnvironmentVariable: pulumi.String("string"),
			Literal:             pulumi.String("string"),
			LiteralWo:           pulumi.String("string"),
			LiteralWoVersion:    pulumi.Int(0),
		},
	},
	TerminationProtection: pulumi.Bool(false),
})

resource "formal_native_user_v3" "nativeUserV3Resource" {
  lifecycle {
    create_before_destroy = true
  }
  label       = "string"
  resource_id = "string"
  gcp_iam = {
    username = "string"
  }
  http_bearer = {
    header = "string"
    token = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
  }
  aws_iam = {
    username = "string"
  }
  hook = {
    code                      = "string"
    output_type               = "string"
    allowlisted_env_variables = ["string"]
    allowlisted_network_hosts = ["string"]
  }
  http_api_key_header = {
    key = "string"
    value = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
  }
  http_api_key_query = {
    key = "string"
    value = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
  }
  http_basic = {
    header = "string"
    password = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
    username = "string"
  }
  basic = {
    password = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
    username = "string"
  }
  kubernetes_inline = {
    kubeconfig = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
  }
  kubernetes_path = {
    kubeconfig_path = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
  }
  azure_iam = {
    username = "string"
  }
  aws_iam_role = {
    role     = "string"
    username = "string"
  }
  snowflake_key = {
    key = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
    username = "string"
  }
  ssh_key = {
    key = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
    username = "string"
    certificate = {
      environment_variable = "string"
      literal              = "string"
      literal_wo           = "string"
      literal_wo_version   = 0
    }
  }
  termination_protection = false
}

var nativeUserV3Resource = new NativeUserV3("nativeUserV3Resource", NativeUserV3Args.builder()
    .label("string")
    .resourceId("string")
    .gcpIam(NativeUserV3GcpIamArgs.builder()
        .username("string")
        .build())
    .httpBearer(NativeUserV3HttpBearerArgs.builder()
        .header("string")
        .token(NativeUserV3HttpBearerTokenArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .build())
    .awsIam(NativeUserV3AwsIamArgs.builder()
        .username("string")
        .build())
    .hook(NativeUserV3HookArgs.builder()
        .code("string")
        .outputType("string")
        .allowlistedEnvVariables("string")
        .allowlistedNetworkHosts("string")
        .build())
    .httpApiKeyHeader(NativeUserV3HttpApiKeyHeaderArgs.builder()
        .key("string")
        .value(NativeUserV3HttpApiKeyHeaderValueArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .build())
    .httpApiKeyQuery(NativeUserV3HttpApiKeyQueryArgs.builder()
        .key("string")
        .value(NativeUserV3HttpApiKeyQueryValueArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .build())
    .httpBasic(NativeUserV3HttpBasicArgs.builder()
        .header("string")
        .password(NativeUserV3HttpBasicPasswordArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .username("string")
        .build())
    .basic(NativeUserV3BasicArgs.builder()
        .password(NativeUserV3BasicPasswordArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .username("string")
        .build())
    .kubernetesInline(NativeUserV3KubernetesInlineArgs.builder()
        .kubeconfig(NativeUserV3KubernetesInlineKubeconfigArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .build())
    .kubernetesPath(NativeUserV3KubernetesPathArgs.builder()
        .kubeconfigPath(NativeUserV3KubernetesPathKubeconfigPathArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .build())
    .azureIam(NativeUserV3AzureIamArgs.builder()
        .username("string")
        .build())
    .awsIamRole(NativeUserV3AwsIamRoleArgs.builder()
        .role("string")
        .username("string")
        .build())
    .snowflakeKey(NativeUserV3SnowflakeKeyArgs.builder()
        .key(NativeUserV3SnowflakeKeyKeyArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .username("string")
        .build())
    .sshKey(NativeUserV3SshKeyArgs.builder()
        .key(NativeUserV3SshKeyKeyArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .username("string")
        .certificate(NativeUserV3SshKeyCertificateArgs.builder()
            .environmentVariable("string")
            .literal("string")
            .literalWo("string")
            .literalWoVersion(0)
            .build())
        .build())
    .terminationProtection(false)
    .build());