coder.getParameter

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

const example = coder.getParameter({
    name: "Region",
    description: "Specify a region to place your workspace.",
    mutable: false,
    type: "string",
    "default": "us-central1-a",
    options: [
        {
            value: "us-central1-a",
            name: "US Central",
            icon: "/icons/1f1fa-1f1f8.png",
        },
        {
            value: "asia-southeast1-a",
            name: "Singapore",
            icon: "/icons/1f1f8-1f1ec.png",
        },
    ],
});
const ami = coder.getParameter({
    name: "Machine Image",
    description: `# Provide the machine image
See the [registry](https://container.registry.blah/namespace) for options.
`,
    options: [{
        value: "ami-xxxxxxxx",
        name: "Ubuntu",
        icon: "/icon/ubuntu.svg",
    }],
});
const isPublicInstance = coder.getParameter({
    name: "Is public instance?",
    type: "bool",
    icon: "/icon/docker.svg",
    "default": "false",
});
const cores = coder.getParameter({
    name: "CPU Cores",
    type: "number",
    icon: "/icon/cpu.svg",
    "default": "3",
    order: 10,
});
const diskSize = coder.getParameter({
    name: "Disk Size",
    type: "number",
    "default": "5",
    order: 8,
    validation: {
        min: 0,
        max: 10,
        monotonic: "increasing",
    },
});
const catLives = coder.getParameter({
    name: "Cat Lives",
    type: "number",
    "default": "9",
    validation: {
        min: 0,
        max: 10,
        monotonic: "decreasing",
    },
});
const fairyTale = coder.getParameter({
    name: "Fairy Tale",
    type: "string",
    mutable: true,
    "default": "Hansel and Gretel",
    ephemeral: true,
});
const users = coder.getParameter({
    name: "system_users",
    displayName: "System users",
    type: "list(string)",
    "default": JSON.stringify([
        "root",
        "user1",
        "user2",
    ]),
});
const homeVolumeSize = coder.getParameter({
    name: "Home Volume Size",
    description: "How large should your home volume be?\n",
    type: "number",
    "default": "30",
    mutable: true,
    order: 3,
    options: [
        {
            name: "30GB",
            value: "30",
        },
        {
            name: "60GB",
            value: "60",
        },
        {
            name: "100GB",
            value: "100",
        },
    ],
    validation: {
        monotonic: "increasing",
    },
});

import pulumi
import json
import pulumi_coder as coder

example = coder.get_parameter(name="Region",
    description="Specify a region to place your workspace.",
    mutable=False,
    type="string",
    default="us-central1-a",
    options=[
        {
            "value": "us-central1-a",
            "name": "US Central",
            "icon": "/icons/1f1fa-1f1f8.png",
        },
        {
            "value": "asia-southeast1-a",
            "name": "Singapore",
            "icon": "/icons/1f1f8-1f1ec.png",
        },
    ])
ami = coder.get_parameter(name="Machine Image",
    description="""# Provide the machine image
See the [registry](https://container.registry.blah/namespace) for options.
""",
    options=[{
        "value": "ami-xxxxxxxx",
        "name": "Ubuntu",
        "icon": "/icon/ubuntu.svg",
    }])
is_public_instance = coder.get_parameter(name="Is public instance?",
    type="bool",
    icon="/icon/docker.svg",
    default="false")
cores = coder.get_parameter(name="CPU Cores",
    type="number",
    icon="/icon/cpu.svg",
    default="3",
    order=10)
disk_size = coder.get_parameter(name="Disk Size",
    type="number",
    default="5",
    order=8,
    validation={
        "min": 0,
        "max": 10,
        "monotonic": "increasing",
    })
cat_lives = coder.get_parameter(name="Cat Lives",
    type="number",
    default="9",
    validation={
        "min": 0,
        "max": 10,
        "monotonic": "decreasing",
    })
fairy_tale = coder.get_parameter(name="Fairy Tale",
    type="string",
    mutable=True,
    default="Hansel and Gretel",
    ephemeral=True)
users = coder.get_parameter(name="system_users",
    display_name="System users",
    type="list(string)",
    default=json.dumps([
        "root",
        "user1",
        "user2",
    ]))
home_volume_size = coder.get_parameter(name="Home Volume Size",
    description="How large should your home volume be?\n",
    type="number",
    default="30",
    mutable=True,
    order=3,
    options=[
        {
            "name": "30GB",
            "value": "30",
        },
        {
            "name": "60GB",
            "value": "60",
        },
        {
            "name": "100GB",
            "value": "100",
        },
    ],
    validation={
        "monotonic": "increasing",
    })

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/coder/v2/coder"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:        "Region",
			Description: pulumi.StringRef("Specify a region to place your workspace."),
			Mutable:     pulumi.BoolRef(false),
			Type:        pulumi.StringRef("string"),
			Default:     pulumi.StringRef("us-central1-a"),
			Options: []coder.GetParameterOption{
				{
					Value: "us-central1-a",
					Name:  "US Central",
					Icon:  pulumi.StringRef("/icons/1f1fa-1f1f8.png"),
				},
				{
					Value: "asia-southeast1-a",
					Name:  "Singapore",
					Icon:  pulumi.StringRef("/icons/1f1f8-1f1ec.png"),
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:        "Machine Image",
			Description: pulumi.StringRef("# Provide the machine image\nSee the [registry](https://container.registry.blah/namespace) for options.\n"),
			Options: []coder.GetParameterOption{
				{
					Value: "ami-xxxxxxxx",
					Name:  "Ubuntu",
					Icon:  pulumi.StringRef("/icon/ubuntu.svg"),
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:    "Is public instance?",
			Type:    pulumi.StringRef("bool"),
			Icon:    pulumi.StringRef("/icon/docker.svg"),
			Default: pulumi.StringRef("false"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:    "CPU Cores",
			Type:    pulumi.StringRef("number"),
			Icon:    pulumi.StringRef("/icon/cpu.svg"),
			Default: pulumi.StringRef("3"),
			Order:   pulumi.Float64Ref(10),
		}, nil)
		if err != nil {
			return err
		}
		_, err = coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:    "Disk Size",
			Type:    pulumi.StringRef("number"),
			Default: pulumi.StringRef("5"),
			Order:   pulumi.Float64Ref(8),
			Validation: coder.GetParameterValidation{
				Min:       pulumi.Float64Ref(0),
				Max:       pulumi.Float64Ref(10),
				Monotonic: pulumi.StringRef("increasing"),
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:    "Cat Lives",
			Type:    pulumi.StringRef("number"),
			Default: pulumi.StringRef("9"),
			Validation: coder.GetParameterValidation{
				Min:       pulumi.Float64Ref(0),
				Max:       pulumi.Float64Ref(10),
				Monotonic: pulumi.StringRef("decreasing"),
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:      "Fairy Tale",
			Type:      pulumi.StringRef("string"),
			Mutable:   pulumi.BoolRef(true),
			Default:   pulumi.StringRef("Hansel and Gretel"),
			Ephemeral: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal([]string{
			"root",
			"user1",
			"user2",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:        "system_users",
			DisplayName: pulumi.StringRef("System users"),
			Type:        pulumi.StringRef("list(string)"),
			Default:     pulumi.StringRef(json0),
		}, nil)
		if err != nil {
			return err
		}
		_, err = coder.GetParameter(ctx, &coder.GetParameterArgs{
			Name:        "Home Volume Size",
			Description: pulumi.StringRef("How large should your home volume be?\n"),
			Type:        pulumi.StringRef("number"),
			Default:     pulumi.StringRef("30"),
			Mutable:     pulumi.BoolRef(true),
			Order:       pulumi.Float64Ref(3),
			Options: []coder.GetParameterOption{
				{
					Name:  "30GB",
					Value: "30",
				},
				{
					Name:  "60GB",
					Value: "60",
				},
				{
					Name:  "100GB",
					Value: "100",
				},
			},
			Validation: coder.GetParameterValidation{
				Monotonic: pulumi.StringRef("increasing"),
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Coder = Pulumi.Coder;

return await Deployment.RunAsync(() => 
{
    var example = Coder.GetParameter.Invoke(new()
    {
        Name = "Region",
        Description = "Specify a region to place your workspace.",
        Mutable = false,
        Type = "string",
        Default = "us-central1-a",
        Options = new[]
        {
            new Coder.Inputs.GetParameterOptionInputArgs
            {
                Value = "us-central1-a",
                Name = "US Central",
                Icon = "/icons/1f1fa-1f1f8.png",
            },
            new Coder.Inputs.GetParameterOptionInputArgs
            {
                Value = "asia-southeast1-a",
                Name = "Singapore",
                Icon = "/icons/1f1f8-1f1ec.png",
            },
        },
    });

    var ami = Coder.GetParameter.Invoke(new()
    {
        Name = "Machine Image",
        Description = @"# Provide the machine image
See the [registry](https://container.registry.blah/namespace) for options.
",
        Options = new[]
        {
            new Coder.Inputs.GetParameterOptionInputArgs
            {
                Value = "ami-xxxxxxxx",
                Name = "Ubuntu",
                Icon = "/icon/ubuntu.svg",
            },
        },
    });

    var isPublicInstance = Coder.GetParameter.Invoke(new()
    {
        Name = "Is public instance?",
        Type = "bool",
        Icon = "/icon/docker.svg",
        Default = "false",
    });

    var cores = Coder.GetParameter.Invoke(new()
    {
        Name = "CPU Cores",
        Type = "number",
        Icon = "/icon/cpu.svg",
        Default = "3",
        Order = 10,
    });

    var diskSize = Coder.GetParameter.Invoke(new()
    {
        Name = "Disk Size",
        Type = "number",
        Default = "5",
        Order = 8,
        Validation = new Coder.Inputs.GetParameterValidationInputArgs
        {
            Min = 0,
            Max = 10,
            Monotonic = "increasing",
        },
    });

    var catLives = Coder.GetParameter.Invoke(new()
    {
        Name = "Cat Lives",
        Type = "number",
        Default = "9",
        Validation = new Coder.Inputs.GetParameterValidationInputArgs
        {
            Min = 0,
            Max = 10,
            Monotonic = "decreasing",
        },
    });

    var fairyTale = Coder.GetParameter.Invoke(new()
    {
        Name = "Fairy Tale",
        Type = "string",
        Mutable = true,
        Default = "Hansel and Gretel",
        Ephemeral = true,
    });

    var users = Coder.GetParameter.Invoke(new()
    {
        Name = "system_users",
        DisplayName = "System users",
        Type = "list(string)",
        Default = JsonSerializer.Serialize(new[]
        {
            "root",
            "user1",
            "user2",
        }),
    });

    var homeVolumeSize = Coder.GetParameter.Invoke(new()
    {
        Name = "Home Volume Size",
        Description = @"How large should your home volume be?
",
        Type = "number",
        Default = "30",
        Mutable = true,
        Order = 3,
        Options = new[]
        {
            new Coder.Inputs.GetParameterOptionInputArgs
            {
                Name = "30GB",
                Value = "30",
            },
            new Coder.Inputs.GetParameterOptionInputArgs
            {
                Name = "60GB",
                Value = "60",
            },
            new Coder.Inputs.GetParameterOptionInputArgs
            {
                Name = "100GB",
                Value = "100",
            },
        },
        Validation = new Coder.Inputs.GetParameterValidationInputArgs
        {
            Monotonic = "increasing",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.coder.CoderFunctions;
import com.pulumi.coder.inputs.GetParameterArgs;
import com.pulumi.coder.inputs.GetParameterValidationArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        final var example = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("Region")
            .description("Specify a region to place your workspace.")
            .mutable(false)
            .type("string")
            .default_("us-central1-a")
            .options(            
                GetParameterOptionArgs.builder()
                    .value("us-central1-a")
                    .name("US Central")
                    .icon("/icons/1f1fa-1f1f8.png")
                    .build(),
                GetParameterOptionArgs.builder()
                    .value("asia-southeast1-a")
                    .name("Singapore")
                    .icon("/icons/1f1f8-1f1ec.png")
                    .build())
            .build());

        final var ami = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("Machine Image")
            .description("""
# Provide the machine image
See the [registry](https://container.registry.blah/namespace) for options.
            """)
            .options(GetParameterOptionArgs.builder()
                .value("ami-xxxxxxxx")
                .name("Ubuntu")
                .icon("/icon/ubuntu.svg")
                .build())
            .build());

        final var isPublicInstance = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("Is public instance?")
            .type("bool")
            .icon("/icon/docker.svg")
            .default_("false")
            .build());

        final var cores = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("CPU Cores")
            .type("number")
            .icon("/icon/cpu.svg")
            .default_("3")
            .order(10)
            .build());

        final var diskSize = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("Disk Size")
            .type("number")
            .default_("5")
            .order(8)
            .validation(GetParameterValidationArgs.builder()
                .min(0)
                .max(10)
                .monotonic("increasing")
                .build())
            .build());

        final var catLives = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("Cat Lives")
            .type("number")
            .default_("9")
            .validation(GetParameterValidationArgs.builder()
                .min(0)
                .max(10)
                .monotonic("decreasing")
                .build())
            .build());

        final var fairyTale = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("Fairy Tale")
            .type("string")
            .mutable(true)
            .default_("Hansel and Gretel")
            .ephemeral(true)
            .build());

        final var users = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("system_users")
            .displayName("System users")
            .type("list(string)")
            .default_(serializeJson(
                jsonArray(
                    "root", 
                    "user1", 
                    "user2"
                )))
            .build());

        final var homeVolumeSize = CoderFunctions.getParameter(GetParameterArgs.builder()
            .name("Home Volume Size")
            .description("""
How large should your home volume be?
            """)
            .type("number")
            .default_("30")
            .mutable(true)
            .order(3)
            .options(            
                GetParameterOptionArgs.builder()
                    .name("30GB")
                    .value("30")
                    .build(),
                GetParameterOptionArgs.builder()
                    .name("60GB")
                    .value("60")
                    .build(),
                GetParameterOptionArgs.builder()
                    .name("100GB")
                    .value("100")
                    .build())
            .validation(GetParameterValidationArgs.builder()
                .monotonic("increasing")
                .build())
            .build());

    }
}

variables:
  example:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: Region
        description: Specify a region to place your workspace.
        mutable: false
        type: string
        default: us-central1-a
        options:
          - value: us-central1-a
            name: US Central
            icon: /icons/1f1fa-1f1f8.png
          - value: asia-southeast1-a
            name: Singapore
            icon: /icons/1f1f8-1f1ec.png
  ami:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: Machine Image
        description: |
          # Provide the machine image
          See the [registry](https://container.registry.blah/namespace) for options.          
        options:
          - value: ami-xxxxxxxx
            name: Ubuntu
            icon: /icon/ubuntu.svg
  isPublicInstance:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: Is public instance?
        type: bool
        icon: /icon/docker.svg
        default: false
  cores:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: CPU Cores
        type: number
        icon: /icon/cpu.svg
        default: 3
        order: 10
  diskSize:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: Disk Size
        type: number
        default: '5'
        order: 8
        validation:
          min: 0
          max: 10
          monotonic: increasing
  catLives:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: Cat Lives
        type: number
        default: '9'
        validation:
          min: 0
          max: 10
          monotonic: decreasing
  fairyTale:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: Fairy Tale
        type: string
        mutable: true
        default: Hansel and Gretel
        ephemeral: true
  users:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: system_users
        displayName: System users
        type: list(string)
        default:
          fn::toJSON:
            - root
            - user1
            - user2
  homeVolumeSize:
    fn::invoke:
      function: coder:getParameter
      arguments:
        name: Home Volume Size
        description: |
          How large should your home volume be?          
        type: number
        default: 30
        mutable: true
        order: 3
        options:
          - name: 30GB
            value: 30
          - name: 60GB
            value: 60
          - name: 100GB
            value: 100
        validation:
          monotonic: increasing

function getParameter(args: GetParameterArgs, opts?: InvokeOptions): Promise<GetParameterResult>
function getParameterOutput(args: GetParameterOutputArgs, opts?: InvokeOptions): Output<GetParameterResult>

def get_parameter(default: Optional[str] = None,
                  description: Optional[str] = None,
                  display_name: Optional[str] = None,
                  ephemeral: Optional[bool] = None,
                  form_type: Optional[str] = None,
                  icon: Optional[str] = None,
                  id: Optional[str] = None,
                  mutable: Optional[bool] = None,
                  name: Optional[str] = None,
                  options: Optional[Sequence[GetParameterOption]] = None,
                  order: Optional[float] = None,
                  styling: Optional[str] = None,
                  type: Optional[str] = None,
                  validation: Optional[GetParameterValidation] = None,
                  opts: Optional[InvokeOptions] = None) -> GetParameterResult
def get_parameter_output(default: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  display_name: Optional[pulumi.Input[str]] = None,
                  ephemeral: Optional[pulumi.Input[bool]] = None,
                  form_type: Optional[pulumi.Input[str]] = None,
                  icon: Optional[pulumi.Input[str]] = None,
                  id: Optional[pulumi.Input[str]] = None,
                  mutable: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  options: Optional[pulumi.Input[Sequence[pulumi.Input[GetParameterOptionArgs]]]] = None,
                  order: Optional[pulumi.Input[float]] = None,
                  styling: Optional[pulumi.Input[str]] = None,
                  type: Optional[pulumi.Input[str]] = None,
                  validation: Optional[pulumi.Input[GetParameterValidationArgs]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetParameterResult]

func GetParameter(ctx *Context, args *GetParameterArgs, opts ...InvokeOption) (*GetParameterResult, error)
func GetParameterOutput(ctx *Context, args *GetParameterOutputArgs, opts ...InvokeOption) GetParameterResultOutput

public static class GetParameter 
{
    public static Task<GetParameterResult> InvokeAsync(GetParameterArgs args, InvokeOptions? opts = null)
    public static Output<GetParameterResult> Invoke(GetParameterInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetParameterResult> getParameter(GetParameterArgs args, InvokeOptions options)
public static Output<GetParameterResult> getParameter(GetParameterArgs args, InvokeOptions options)

fn::invoke:
  function: coder:index/getParameter:getParameter
  arguments:
    # arguments dictionary