equinix.fabric.getMarketplaceSubscription

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

const subscription-test = equinix.fabric.getMarketplaceSubscription({
    uuid: "<uuid_of_marketplace_subscription>",
});
export const id = subscription_test.then(subscription_test => subscription_test.id);
export const status = subscription_test.then(subscription_test => subscription_test.status);
export const marketplace = subscription_test.then(subscription_test => subscription_test.marketplace);
export const offerType = subscription_test.then(subscription_test => subscription_test.offerType);
export const isAutoRenew = subscription_test.then(subscription_test => subscription_test.isAutoRenew);

import pulumi
import pulumi_equinix as equinix

subscription_test = equinix.fabric.get_marketplace_subscription(uuid="<uuid_of_marketplace_subscription>")
pulumi.export("id", subscription_test.id)
pulumi.export("status", subscription_test.status)
pulumi.export("marketplace", subscription_test.marketplace)
pulumi.export("offerType", subscription_test.offer_type)
pulumi.export("isAutoRenew", subscription_test.is_auto_renew)

package main

import (
	"github.com/equinix/pulumi-equinix/sdk/go/equinix/fabric"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		subscription_test, err := fabric.GetMarketplaceSubscription(ctx, &fabric.GetMarketplaceSubscriptionArgs{
			Uuid: "<uuid_of_marketplace_subscription>",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("id", subscription_test.Id)
		ctx.Export("status", subscription_test.Status)
		ctx.Export("marketplace", subscription_test.Marketplace)
		ctx.Export("offerType", subscription_test.OfferType)
		ctx.Export("isAutoRenew", subscription_test.IsAutoRenew)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var subscription_test = Equinix.Fabric.GetMarketplaceSubscription.Invoke(new()
    {
        Uuid = "<uuid_of_marketplace_subscription>",
    });

    return new Dictionary<string, object?>
    {
        ["id"] = subscription_test.Apply(subscription_test => subscription_test.Apply(getMarketplaceSubscriptionResult => getMarketplaceSubscriptionResult.Id)),
        ["status"] = subscription_test.Apply(subscription_test => subscription_test.Apply(getMarketplaceSubscriptionResult => getMarketplaceSubscriptionResult.Status)),
        ["marketplace"] = subscription_test.Apply(subscription_test => subscription_test.Apply(getMarketplaceSubscriptionResult => getMarketplaceSubscriptionResult.Marketplace)),
        ["offerType"] = subscription_test.Apply(subscription_test => subscription_test.Apply(getMarketplaceSubscriptionResult => getMarketplaceSubscriptionResult.OfferType)),
        ["isAutoRenew"] = subscription_test.Apply(subscription_test => subscription_test.Apply(getMarketplaceSubscriptionResult => getMarketplaceSubscriptionResult.IsAutoRenew)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.equinix.fabric.FabricFunctions;
import com.pulumi.equinix.fabric.inputs.GetMarketplaceSubscriptionArgs;
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 subscription-test = FabricFunctions.getMarketplaceSubscription(GetMarketplaceSubscriptionArgs.builder()
            .uuid("<uuid_of_marketplace_subscription>")
            .build());

        ctx.export("id", subscription_test.id());
        ctx.export("status", subscription_test.status());
        ctx.export("marketplace", subscription_test.marketplace());
        ctx.export("offerType", subscription_test.offerType());
        ctx.export("isAutoRenew", subscription_test.isAutoRenew());
    }
}

variables:
  subscription-test:
    fn::invoke:
      Function: equinix:fabric:getMarketplaceSubscription
      Arguments:
        uuid: <uuid_of_marketplace_subscription>
outputs:
  id: ${["subscription-test"].id}
  status: ${["subscription-test"].status}
  marketplace: ${["subscription-test"].marketplace}
  offerType: ${["subscription-test"].offerType}
  isAutoRenew: ${["subscription-test"].isAutoRenew}

function getMarketplaceSubscription(args: GetMarketplaceSubscriptionArgs, opts?: InvokeOptions): Promise<GetMarketplaceSubscriptionResult>
function getMarketplaceSubscriptionOutput(args: GetMarketplaceSubscriptionOutputArgs, opts?: InvokeOptions): Output<GetMarketplaceSubscriptionResult>

def get_marketplace_subscription(uuid: Optional[str] = None,
                                 opts: Optional[InvokeOptions] = None) -> GetMarketplaceSubscriptionResult
def get_marketplace_subscription_output(uuid: Optional[pulumi.Input[str]] = None,
                                 opts: Optional[InvokeOptions] = None) -> Output[GetMarketplaceSubscriptionResult]

func GetMarketplaceSubscription(ctx *Context, args *GetMarketplaceSubscriptionArgs, opts ...InvokeOption) (*GetMarketplaceSubscriptionResult, error)
func GetMarketplaceSubscriptionOutput(ctx *Context, args *GetMarketplaceSubscriptionOutputArgs, opts ...InvokeOption) GetMarketplaceSubscriptionResultOutput

public static class GetMarketplaceSubscription 
{
    public static Task<GetMarketplaceSubscriptionResult> InvokeAsync(GetMarketplaceSubscriptionArgs args, InvokeOptions? opts = null)
    public static Output<GetMarketplaceSubscriptionResult> Invoke(GetMarketplaceSubscriptionInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetMarketplaceSubscriptionResult> getMarketplaceSubscription(GetMarketplaceSubscriptionArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: equinix:fabric/getMarketplaceSubscription:getMarketplaceSubscription
  arguments:
    # arguments dictionary