digitalocean.getMicrodropletImages

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

const all = digitalocean.getMicrodropletImages({});
const available = digitalocean.getMicrodropletImages({
    filters: [{
        key: "status",
        values: ["IMAGE_AVAILABLE"],
    }],
});
const newestFirst = digitalocean.getMicrodropletImages({
    sorts: [{
        key: "created_at",
        direction: "desc",
    }],
});

import pulumi
import pulumi_digitalocean as digitalocean

all = digitalocean.get_microdroplet_images()
available = digitalocean.get_microdroplet_images(filters=[{
    "key": "status",
    "values": ["IMAGE_AVAILABLE"],
}])
newest_first = digitalocean.get_microdroplet_images(sorts=[{
    "key": "created_at",
    "direction": "desc",
}])

package main

import (
	"github.com/pulumi/pulumi-digitalocean/sdk/v4/go/digitalocean"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := digitalocean.GetMicrodropletImages(ctx, &digitalocean.GetMicrodropletImagesArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = digitalocean.GetMicrodropletImages(ctx, &digitalocean.GetMicrodropletImagesArgs{
			Filters: []digitalocean.GetMicrodropletImagesFilter{
				{
					Key: "status",
					Values: []string{
						"IMAGE_AVAILABLE",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = digitalocean.GetMicrodropletImages(ctx, &digitalocean.GetMicrodropletImagesArgs{
			Sorts: []digitalocean.GetMicrodropletImagesSort{
				{
					Key:       "created_at",
					Direction: pulumi.StringRef("desc"),
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var all = DigitalOcean.GetMicrodropletImages.Invoke();

    var available = DigitalOcean.GetMicrodropletImages.Invoke(new()
    {
        Filters = new[]
        {
            new DigitalOcean.Inputs.GetMicrodropletImagesFilterInputArgs
            {
                Key = "status",
                Values = new[]
                {
                    "IMAGE_AVAILABLE",
                },
            },
        },
    });

    var newestFirst = DigitalOcean.GetMicrodropletImages.Invoke(new()
    {
        Sorts = new[]
        {
            new DigitalOcean.Inputs.GetMicrodropletImagesSortInputArgs
            {
                Key = "created_at",
                Direction = "desc",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.digitalocean.DigitaloceanFunctions;
import com.pulumi.digitalocean.inputs.GetMicrodropletImagesArgs;
import com.pulumi.digitalocean.inputs.GetMicrodropletImagesFilterArgs;
import com.pulumi.digitalocean.inputs.GetMicrodropletImagesSortArgs;
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 all = DigitaloceanFunctions.getMicrodropletImages(GetMicrodropletImagesArgs.builder()
            .build());

        final var available = DigitaloceanFunctions.getMicrodropletImages(GetMicrodropletImagesArgs.builder()
            .filters(GetMicrodropletImagesFilterArgs.builder()
                .key("status")
                .values("IMAGE_AVAILABLE")
                .build())
            .build());

        final var newestFirst = DigitaloceanFunctions.getMicrodropletImages(GetMicrodropletImagesArgs.builder()
            .sorts(GetMicrodropletImagesSortArgs.builder()
                .key("created_at")
                .direction("desc")
                .build())
            .build());

    }
}

variables:
  all:
    fn::invoke:
      function: digitalocean:getMicrodropletImages
      arguments: {}
  available:
    fn::invoke:
      function: digitalocean:getMicrodropletImages
      arguments:
        filters:
          - key: status
            values:
              - IMAGE_AVAILABLE
  newestFirst:
    fn::invoke:
      function: digitalocean:getMicrodropletImages
      arguments:
        sorts:
          - key: created_at
            direction: desc

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

data "digitalocean_getmicrodropletimages" "all" {
}
data "digitalocean_getmicrodropletimages" "available" {
  filters {
    key    = "status"
    values = ["IMAGE_AVAILABLE"]
  }
}
data "digitalocean_getmicrodropletimages" "newestFirst" {
  sorts {
    key       = "created_at"
    direction = "desc"
  }
}

function getMicrodropletImages(args: GetMicrodropletImagesArgs, opts?: InvokeOptions): Promise<GetMicrodropletImagesResult>
function getMicrodropletImagesOutput(args: GetMicrodropletImagesOutputArgs, opts?: InvokeOptions): Output<GetMicrodropletImagesResult>

def get_microdroplet_images(filters: Optional[Sequence[GetMicrodropletImagesFilter]] = None,
                            sorts: Optional[Sequence[GetMicrodropletImagesSort]] = None,
                            opts: Optional[InvokeOptions] = None) -> GetMicrodropletImagesResult
def get_microdroplet_images_output(filters: pulumi.Input[Optional[Sequence[pulumi.Input[GetMicrodropletImagesFilterArgs]]]] = None,
                            sorts: pulumi.Input[Optional[Sequence[pulumi.Input[GetMicrodropletImagesSortArgs]]]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetMicrodropletImagesResult]

func GetMicrodropletImages(ctx *Context, args *GetMicrodropletImagesArgs, opts ...InvokeOption) (*GetMicrodropletImagesResult, error)
func GetMicrodropletImagesOutput(ctx *Context, args *GetMicrodropletImagesOutputArgs, opts ...InvokeOption) GetMicrodropletImagesResultOutput

public static class GetMicrodropletImages 
{
    public static Task<GetMicrodropletImagesResult> InvokeAsync(GetMicrodropletImagesArgs args, InvokeOptions? opts = null)
    public static Output<GetMicrodropletImagesResult> Invoke(GetMicrodropletImagesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetMicrodropletImagesResult> getMicrodropletImages(GetMicrodropletImagesArgs args, InvokeOptions options)
public static Output<GetMicrodropletImagesResult> getMicrodropletImages(GetMicrodropletImagesArgs args, InvokeOptions options)

fn::invoke:
  function: digitalocean:index/getMicrodropletImages:getMicrodropletImages
  arguments:
    # arguments dictionary

data "digitalocean_get_microdroplet_images" "name" {
    # arguments
}