snowflake.getSystemGenerateScimAccessToken

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

const scim = snowflake.getSystemGenerateScimAccessToken({
    integrationName: "AAD_PROVISIONING",
});

import pulumi
import pulumi_snowflake as snowflake

scim = snowflake.get_system_generate_scim_access_token(integration_name="AAD_PROVISIONING")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := snowflake.GetSystemGenerateScimAccessToken(ctx, &snowflake.GetSystemGenerateScimAccessTokenArgs{
			IntegrationName: "AAD_PROVISIONING",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var scim = Snowflake.GetSystemGenerateScimAccessToken.Invoke(new()
    {
        IntegrationName = "AAD_PROVISIONING",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.snowflake.SnowflakeFunctions;
import com.pulumi.snowflake.inputs.GetSystemGenerateScimAccessTokenArgs;
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 scim = SnowflakeFunctions.getSystemGenerateScimAccessToken(GetSystemGenerateScimAccessTokenArgs.builder()
            .integrationName("AAD_PROVISIONING")
            .build());

    }
}

variables:
  scim:
    fn::invoke:
      Function: snowflake:getSystemGenerateScimAccessToken
      Arguments:
        integrationName: AAD_PROVISIONING

function getSystemGenerateScimAccessToken(args: GetSystemGenerateScimAccessTokenArgs, opts?: InvokeOptions): Promise<GetSystemGenerateScimAccessTokenResult>
function getSystemGenerateScimAccessTokenOutput(args: GetSystemGenerateScimAccessTokenOutputArgs, opts?: InvokeOptions): Output<GetSystemGenerateScimAccessTokenResult>

def get_system_generate_scim_access_token(integration_name: Optional[str] = None,
                                          opts: Optional[InvokeOptions] = None) -> GetSystemGenerateScimAccessTokenResult
def get_system_generate_scim_access_token_output(integration_name: Optional[pulumi.Input[str]] = None,
                                          opts: Optional[InvokeOptions] = None) -> Output[GetSystemGenerateScimAccessTokenResult]

func GetSystemGenerateScimAccessToken(ctx *Context, args *GetSystemGenerateScimAccessTokenArgs, opts ...InvokeOption) (*GetSystemGenerateScimAccessTokenResult, error)
func GetSystemGenerateScimAccessTokenOutput(ctx *Context, args *GetSystemGenerateScimAccessTokenOutputArgs, opts ...InvokeOption) GetSystemGenerateScimAccessTokenResultOutput

public static class GetSystemGenerateScimAccessToken 
{
    public static Task<GetSystemGenerateScimAccessTokenResult> InvokeAsync(GetSystemGenerateScimAccessTokenArgs args, InvokeOptions? opts = null)
    public static Output<GetSystemGenerateScimAccessTokenResult> Invoke(GetSystemGenerateScimAccessTokenInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSystemGenerateScimAccessTokenResult> getSystemGenerateScimAccessToken(GetSystemGenerateScimAccessTokenArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: snowflake:index/getSystemGenerateScimAccessToken:getSystemGenerateScimAccessToken
  arguments:
    # arguments dictionary