auth0.getConnectionScimConfiguration

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

const myEnterpriseConnection = new auth0.Connection("my_enterprise_connection", {
    name: "my-enterprise-connection",
    displayName: "My Enterprise Connection",
    strategy: "okta",
    options: {
        clientId: "1234567",
        clientSecret: "1234567",
        issuer: "https://example.okta.com",
        jwksUri: "https://example.okta.com/oauth2/v1/keys",
        tokenEndpoint: "https://example.okta.com/oauth2/v1/token",
        authorizationEndpoint: "https://example.okta.com/oauth2/v1/authorize",
    },
});
const myConnScimConfiguration = new auth0.ConnectionScimConfiguration("my_conn_scim_configuration", {connectionId: myEnterpriseConnection.id});
// A data source for an Auth0 Connection SCIM Configuration.
const myConnScimConfigurationData = auth0.getConnectionScimConfigurationOutput({
    connectionId: myConnScimConfiguration.id,
});

import pulumi
import pulumi_auth0 as auth0

my_enterprise_connection = auth0.Connection("my_enterprise_connection",
    name="my-enterprise-connection",
    display_name="My Enterprise Connection",
    strategy="okta",
    options={
        "client_id": "1234567",
        "client_secret": "1234567",
        "issuer": "https://example.okta.com",
        "jwks_uri": "https://example.okta.com/oauth2/v1/keys",
        "token_endpoint": "https://example.okta.com/oauth2/v1/token",
        "authorization_endpoint": "https://example.okta.com/oauth2/v1/authorize",
    })
my_conn_scim_configuration = auth0.ConnectionScimConfiguration("my_conn_scim_configuration", connection_id=my_enterprise_connection.id)
# A data source for an Auth0 Connection SCIM Configuration.
my_conn_scim_configuration_data = auth0.get_connection_scim_configuration_output(connection_id=my_conn_scim_configuration.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myEnterpriseConnection, err := auth0.NewConnection(ctx, "my_enterprise_connection", &auth0.ConnectionArgs{
			Name:        pulumi.String("my-enterprise-connection"),
			DisplayName: pulumi.String("My Enterprise Connection"),
			Strategy:    pulumi.String("okta"),
			Options: &auth0.ConnectionOptionsArgs{
				ClientId:              pulumi.String("1234567"),
				ClientSecret:          pulumi.String("1234567"),
				Issuer:                pulumi.String("https://example.okta.com"),
				JwksUri:               pulumi.String("https://example.okta.com/oauth2/v1/keys"),
				TokenEndpoint:         pulumi.String("https://example.okta.com/oauth2/v1/token"),
				AuthorizationEndpoint: pulumi.String("https://example.okta.com/oauth2/v1/authorize"),
			},
		})
		if err != nil {
			return err
		}
		myConnScimConfiguration, err := auth0.NewConnectionScimConfiguration(ctx, "my_conn_scim_configuration", &auth0.ConnectionScimConfigurationArgs{
			ConnectionId: myEnterpriseConnection.ID(),
		})
		if err != nil {
			return err
		}
		// A data source for an Auth0 Connection SCIM Configuration.
		_ = auth0.LookupConnectionScimConfigurationOutput(ctx, auth0.GetConnectionScimConfigurationOutputArgs{
			ConnectionId: myConnScimConfiguration.ID(),
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myEnterpriseConnection = new Auth0.Connection("my_enterprise_connection", new()
    {
        Name = "my-enterprise-connection",
        DisplayName = "My Enterprise Connection",
        Strategy = "okta",
        Options = new Auth0.Inputs.ConnectionOptionsArgs
        {
            ClientId = "1234567",
            ClientSecret = "1234567",
            Issuer = "https://example.okta.com",
            JwksUri = "https://example.okta.com/oauth2/v1/keys",
            TokenEndpoint = "https://example.okta.com/oauth2/v1/token",
            AuthorizationEndpoint = "https://example.okta.com/oauth2/v1/authorize",
        },
    });

    var myConnScimConfiguration = new Auth0.ConnectionScimConfiguration("my_conn_scim_configuration", new()
    {
        ConnectionId = myEnterpriseConnection.Id,
    });

    // A data source for an Auth0 Connection SCIM Configuration.
    var myConnScimConfigurationData = Auth0.GetConnectionScimConfiguration.Invoke(new()
    {
        ConnectionId = myConnScimConfiguration.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.Connection;
import com.pulumi.auth0.ConnectionArgs;
import com.pulumi.auth0.inputs.ConnectionOptionsArgs;
import com.pulumi.auth0.ConnectionScimConfiguration;
import com.pulumi.auth0.ConnectionScimConfigurationArgs;
import com.pulumi.auth0.Auth0Functions;
import com.pulumi.auth0.inputs.GetConnectionScimConfigurationArgs;
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) {
        var myEnterpriseConnection = new Connection("myEnterpriseConnection", ConnectionArgs.builder()
            .name("my-enterprise-connection")
            .displayName("My Enterprise Connection")
            .strategy("okta")
            .options(ConnectionOptionsArgs.builder()
                .clientId("1234567")
                .clientSecret("1234567")
                .issuer("https://example.okta.com")
                .jwksUri("https://example.okta.com/oauth2/v1/keys")
                .tokenEndpoint("https://example.okta.com/oauth2/v1/token")
                .authorizationEndpoint("https://example.okta.com/oauth2/v1/authorize")
                .build())
            .build());

        var myConnScimConfiguration = new ConnectionScimConfiguration("myConnScimConfiguration", ConnectionScimConfigurationArgs.builder()
            .connectionId(myEnterpriseConnection.id())
            .build());

        // A data source for an Auth0 Connection SCIM Configuration.
        final var myConnScimConfigurationData = Auth0Functions.getConnectionScimConfiguration(GetConnectionScimConfigurationArgs.builder()
            .connectionId(myConnScimConfiguration.id())
            .build());

    }
}

resources:
  myEnterpriseConnection:
    type: auth0:Connection
    name: my_enterprise_connection
    properties:
      name: my-enterprise-connection
      displayName: My Enterprise Connection
      strategy: okta
      options:
        clientId: '1234567'
        clientSecret: '1234567'
        issuer: https://example.okta.com
        jwksUri: https://example.okta.com/oauth2/v1/keys
        tokenEndpoint: https://example.okta.com/oauth2/v1/token
        authorizationEndpoint: https://example.okta.com/oauth2/v1/authorize
  myConnScimConfiguration:
    type: auth0:ConnectionScimConfiguration
    name: my_conn_scim_configuration
    properties:
      connectionId: ${myEnterpriseConnection.id}
variables:
  # A data source for an Auth0 Connection SCIM Configuration.
  myConnScimConfigurationData:
    fn::invoke:
      Function: auth0:getConnectionScimConfiguration
      Arguments:
        connectionId: ${myConnScimConfiguration.id}

function getConnectionScimConfiguration(args: GetConnectionScimConfigurationArgs, opts?: InvokeOptions): Promise<GetConnectionScimConfigurationResult>
function getConnectionScimConfigurationOutput(args: GetConnectionScimConfigurationOutputArgs, opts?: InvokeOptions): Output<GetConnectionScimConfigurationResult>

def get_connection_scim_configuration(connection_id: Optional[str] = None,
                                      default_mappings: Optional[Sequence[GetConnectionScimConfigurationDefaultMapping]] = None,
                                      mappings: Optional[Sequence[GetConnectionScimConfigurationMapping]] = None,
                                      opts: Optional[InvokeOptions] = None) -> GetConnectionScimConfigurationResult
def get_connection_scim_configuration_output(connection_id: Optional[pulumi.Input[str]] = None,
                                      default_mappings: Optional[pulumi.Input[Sequence[pulumi.Input[GetConnectionScimConfigurationDefaultMappingArgs]]]] = None,
                                      mappings: Optional[pulumi.Input[Sequence[pulumi.Input[GetConnectionScimConfigurationMappingArgs]]]] = None,
                                      opts: Optional[InvokeOptions] = None) -> Output[GetConnectionScimConfigurationResult]

func LookupConnectionScimConfiguration(ctx *Context, args *LookupConnectionScimConfigurationArgs, opts ...InvokeOption) (*LookupConnectionScimConfigurationResult, error)
func LookupConnectionScimConfigurationOutput(ctx *Context, args *LookupConnectionScimConfigurationOutputArgs, opts ...InvokeOption) LookupConnectionScimConfigurationResultOutput

public static class GetConnectionScimConfiguration 
{
    public static Task<GetConnectionScimConfigurationResult> InvokeAsync(GetConnectionScimConfigurationArgs args, InvokeOptions? opts = null)
    public static Output<GetConnectionScimConfigurationResult> Invoke(GetConnectionScimConfigurationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetConnectionScimConfigurationResult> getConnectionScimConfiguration(GetConnectionScimConfigurationArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: auth0:index/getConnectionScimConfiguration:getConnectionScimConfiguration
  arguments:
    # arguments dictionary