discord.getColor

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

const blue = discord.getColor({
    hex: "#4287f5",
});
const green = discord.getColor({
    rgb: "rgb(46, 204, 113)",
});
const blueRole = new discord.Role("blue", {color: blue.then(blue => blue.dec)});
const greenRole = new discord.Role("green", {color: green.then(green => green.dec)});

import pulumi
import pulumi_discord as discord

blue = discord.get_color(hex="#4287f5")
green = discord.get_color(rgb="rgb(46, 204, 113)")
blue_role = discord.Role("blue", color=blue.dec)
green_role = discord.Role("green", color=green.dec)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/discord/v2/discord"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		blue, err := discord.GetColor(ctx, &discord.GetColorArgs{
			Hex: pulumi.StringRef("#4287f5"),
		}, nil)
		if err != nil {
			return err
		}
		green, err := discord.GetColor(ctx, &discord.GetColorArgs{
			Rgb: pulumi.StringRef("rgb(46, 204, 113)"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = discord.NewRole(ctx, "blue", &discord.RoleArgs{
			Color: pulumi.Float64(blue.Dec),
		})
		if err != nil {
			return err
		}
		_, err = discord.NewRole(ctx, "green", &discord.RoleArgs{
			Color: pulumi.Float64(green.Dec),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var blue = Discord.GetColor.Invoke(new()
    {
        Hex = "#4287f5",
    });

    var green = Discord.GetColor.Invoke(new()
    {
        Rgb = "rgb(46, 204, 113)",
    });

    var blueRole = new Discord.Role("blue", new()
    {
        Color = blue.Apply(getColorResult => getColorResult.Dec),
    });

    var greenRole = new Discord.Role("green", new()
    {
        Color = green.Apply(getColorResult => getColorResult.Dec),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.discord.DiscordFunctions;
import com.pulumi.discord.inputs.GetColorArgs;
import com.pulumi.discord.Role;
import com.pulumi.discord.RoleArgs;
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 blue = DiscordFunctions.getColor(GetColorArgs.builder()
            .hex("#4287f5")
            .build());

        final var green = DiscordFunctions.getColor(GetColorArgs.builder()
            .rgb("rgb(46, 204, 113)")
            .build());

        var blueRole = new Role("blueRole", RoleArgs.builder()
            .color(blue.dec())
            .build());

        var greenRole = new Role("greenRole", RoleArgs.builder()
            .color(green.dec())
            .build());

    }
}

resources:
  blueRole:
    type: discord:Role
    name: blue
    properties:
      color: ${blue.dec}
  greenRole:
    type: discord:Role
    name: green
    properties:
      color: ${green.dec}
variables:
  blue:
    fn::invoke:
      function: discord:getColor
      arguments:
        hex: '#4287f5'
  green:
    fn::invoke:
      function: discord:getColor
      arguments:
        rgb: rgb(46, 204, 113)

function getColor(args: GetColorArgs, opts?: InvokeOptions): Promise<GetColorResult>
function getColorOutput(args: GetColorOutputArgs, opts?: InvokeOptions): Output<GetColorResult>

def get_color(hex: Optional[str] = None,
              id: Optional[str] = None,
              rgb: Optional[str] = None,
              opts: Optional[InvokeOptions] = None) -> GetColorResult
def get_color_output(hex: Optional[pulumi.Input[str]] = None,
              id: Optional[pulumi.Input[str]] = None,
              rgb: Optional[pulumi.Input[str]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[GetColorResult]

func GetColor(ctx *Context, args *GetColorArgs, opts ...InvokeOption) (*GetColorResult, error)
func GetColorOutput(ctx *Context, args *GetColorOutputArgs, opts ...InvokeOption) GetColorResultOutput

public static class GetColor 
{
    public static Task<GetColorResult> InvokeAsync(GetColorArgs args, InvokeOptions? opts = null)
    public static Output<GetColorResult> Invoke(GetColorInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetColorResult> getColor(GetColorArgs args, InvokeOptions options)
public static Output<GetColorResult> getColor(GetColorArgs args, InvokeOptions options)

fn::invoke:
  function: discord:index/getColor:getColor
  arguments:
    # arguments dictionary