opentelekomcloud.getApigwApiHistoryV2

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

const config = new pulumi.Config();
const gatewayId = config.requireObject("gatewayId");
const environmentId = config.requireObject("environmentId");
const apiId = config.requireObject("apiId");
const pub = new opentelekomcloud.ApigwApiPublishmentV2("pub", {
    gatewayId: _var.instance_id,
    environmentId: environmentId,
    apiId: apiId,
});
const hist = opentelekomcloud.getApigwApiHistoryV2({
    gatewayId: opentelekomcloud_apigw_gateway_v2.gateway.id,
    environmentId: opentelekomcloud_apigw_environment_v2.env.id,
    apiId: opentelekomcloud_apigw_api_v2.api.id,
});

import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

config = pulumi.Config()
gateway_id = config.require_object("gatewayId")
environment_id = config.require_object("environmentId")
api_id = config.require_object("apiId")
pub = opentelekomcloud.ApigwApiPublishmentV2("pub",
    gateway_id=var["instance_id"],
    environment_id=environment_id,
    api_id=api_id)
hist = opentelekomcloud.get_apigw_api_history_v2(gateway_id=opentelekomcloud_apigw_gateway_v2["gateway"]["id"],
    environment_id=opentelekomcloud_apigw_environment_v2["env"]["id"],
    api_id=opentelekomcloud_apigw_api_v2["api"]["id"])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"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, "")
		gatewayId := cfg.RequireObject("gatewayId")
		environmentId := cfg.RequireObject("environmentId")
		apiId := cfg.RequireObject("apiId")
		_, err := opentelekomcloud.NewApigwApiPublishmentV2(ctx, "pub", &opentelekomcloud.ApigwApiPublishmentV2Args{
			GatewayId:     pulumi.Any(_var.Instance_id),
			EnvironmentId: pulumi.Any(environmentId),
			ApiId:         pulumi.Any(apiId),
		})
		if err != nil {
			return err
		}
		_, err = opentelekomcloud.GetApigwApiHistoryV2(ctx, &opentelekomcloud.GetApigwApiHistoryV2Args{
			GatewayId:     opentelekomcloud_apigw_gateway_v2.Gateway.Id,
			EnvironmentId: pulumi.StringRef(opentelekomcloud_apigw_environment_v2.Env.Id),
			ApiId:         opentelekomcloud_apigw_api_v2.Api.Id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var gatewayId = config.RequireObject<dynamic>("gatewayId");
    var environmentId = config.RequireObject<dynamic>("environmentId");
    var apiId = config.RequireObject<dynamic>("apiId");
    var pub = new Opentelekomcloud.ApigwApiPublishmentV2("pub", new()
    {
        GatewayId = @var.Instance_id,
        EnvironmentId = environmentId,
        ApiId = apiId,
    });

    var hist = Opentelekomcloud.GetApigwApiHistoryV2.Invoke(new()
    {
        GatewayId = opentelekomcloud_apigw_gateway_v2.Gateway.Id,
        EnvironmentId = opentelekomcloud_apigw_environment_v2.Env.Id,
        ApiId = opentelekomcloud_apigw_api_v2.Api.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ApigwApiPublishmentV2;
import com.pulumi.opentelekomcloud.ApigwApiPublishmentV2Args;
import com.pulumi.opentelekomcloud.OpentelekomcloudFunctions;
import com.pulumi.opentelekomcloud.inputs.GetApigwApiHistoryV2Args;
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 config = ctx.config();
        final var gatewayId = config.get("gatewayId");
        final var environmentId = config.get("environmentId");
        final var apiId = config.get("apiId");
        var pub = new ApigwApiPublishmentV2("pub", ApigwApiPublishmentV2Args.builder()
            .gatewayId(var_.instance_id())
            .environmentId(environmentId)
            .apiId(apiId)
            .build());

        final var hist = OpentelekomcloudFunctions.getApigwApiHistoryV2(GetApigwApiHistoryV2Args.builder()
            .gatewayId(opentelekomcloud_apigw_gateway_v2.gateway().id())
            .environmentId(opentelekomcloud_apigw_environment_v2.env().id())
            .apiId(opentelekomcloud_apigw_api_v2.api().id())
            .build());

    }
}

configuration:
  gatewayId:
    type: dynamic
  environmentId:
    type: dynamic
  apiId:
    type: dynamic
resources:
  pub:
    type: opentelekomcloud:ApigwApiPublishmentV2
    properties:
      gatewayId: ${var.instance_id}
      environmentId: ${environmentId}
      apiId: ${apiId}
variables:
  hist:
    fn::invoke:
      function: opentelekomcloud:getApigwApiHistoryV2
      arguments:
        gatewayId: ${opentelekomcloud_apigw_gateway_v2.gateway.id}
        environmentId: ${opentelekomcloud_apigw_environment_v2.env.id}
        apiId: ${opentelekomcloud_apigw_api_v2.api.id}

function getApigwApiHistoryV2(args: GetApigwApiHistoryV2Args, opts?: InvokeOptions): Promise<GetApigwApiHistoryV2Result>
function getApigwApiHistoryV2Output(args: GetApigwApiHistoryV2OutputArgs, opts?: InvokeOptions): Output<GetApigwApiHistoryV2Result>

def get_apigw_api_history_v2(api_id: Optional[str] = None,
                             environment_id: Optional[str] = None,
                             environment_name: Optional[str] = None,
                             gateway_id: Optional[str] = None,
                             id: Optional[str] = None,
                             opts: Optional[InvokeOptions] = None) -> GetApigwApiHistoryV2Result
def get_apigw_api_history_v2_output(api_id: Optional[pulumi.Input[str]] = None,
                             environment_id: Optional[pulumi.Input[str]] = None,
                             environment_name: Optional[pulumi.Input[str]] = None,
                             gateway_id: Optional[pulumi.Input[str]] = None,
                             id: Optional[pulumi.Input[str]] = None,
                             opts: Optional[InvokeOptions] = None) -> Output[GetApigwApiHistoryV2Result]

func GetApigwApiHistoryV2(ctx *Context, args *GetApigwApiHistoryV2Args, opts ...InvokeOption) (*GetApigwApiHistoryV2Result, error)
func GetApigwApiHistoryV2Output(ctx *Context, args *GetApigwApiHistoryV2OutputArgs, opts ...InvokeOption) GetApigwApiHistoryV2ResultOutput

public static class GetApigwApiHistoryV2 
{
    public static Task<GetApigwApiHistoryV2Result> InvokeAsync(GetApigwApiHistoryV2Args args, InvokeOptions? opts = null)
    public static Output<GetApigwApiHistoryV2Result> Invoke(GetApigwApiHistoryV2InvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetApigwApiHistoryV2Result> getApigwApiHistoryV2(GetApigwApiHistoryV2Args args, InvokeOptions options)
public static Output<GetApigwApiHistoryV2Result> getApigwApiHistoryV2(GetApigwApiHistoryV2Args args, InvokeOptions options)

fn::invoke:
  function: opentelekomcloud:index/getApigwApiHistoryV2:getApigwApiHistoryV2
  arguments:
    # arguments dictionary