auth0.OrganizationClients

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

const myOrganization = new auth0.Organization("my_organization", {
    name: "my-organization",
    displayName: "My Organization",
});
const myClient = new auth0.Client("my_client", {name: "My Application"});
const myOtherClient = new auth0.Client("my_other_client", {name: "My Other Application"});
// Entitle both applications to the organization in one authoritative resource (EA only).
// Use this instead of auth0_organization_client when you want Terraform to own the full
// set of associations; do not use both resources on the same organization.
const myOrgClients = new auth0.OrganizationClients("my_org_clients", {
    organizationId: myOrganization.id,
    clients: [
        {
            clientId: myClient.id,
            useForMemberAccess: true,
        },
        {
            clientId: myOtherClient.id,
        },
    ],
});

import pulumi
import pulumi_auth0 as auth0

my_organization = auth0.Organization("my_organization",
    name="my-organization",
    display_name="My Organization")
my_client = auth0.Client("my_client", name="My Application")
my_other_client = auth0.Client("my_other_client", name="My Other Application")
# Entitle both applications to the organization in one authoritative resource (EA only).
# Use this instead of auth0_organization_client when you want Terraform to own the full
# set of associations; do not use both resources on the same organization.
my_org_clients = auth0.OrganizationClients("my_org_clients",
    organization_id=my_organization.id,
    clients=[
        {
            "client_id": my_client.id,
            "use_for_member_access": True,
        },
        {
            "client_id": my_other_client.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 {
		myOrganization, err := auth0.NewOrganization(ctx, "my_organization", &auth0.OrganizationArgs{
			Name:        pulumi.String("my-organization"),
			DisplayName: pulumi.String("My Organization"),
		})
		if err != nil {
			return err
		}
		myClient, err := auth0.NewClient(ctx, "my_client", &auth0.ClientArgs{
			Name: pulumi.String("My Application"),
		})
		if err != nil {
			return err
		}
		myOtherClient, err := auth0.NewClient(ctx, "my_other_client", &auth0.ClientArgs{
			Name: pulumi.String("My Other Application"),
		})
		if err != nil {
			return err
		}
		// Entitle both applications to the organization in one authoritative resource (EA only).
		// Use this instead of auth0_organization_client when you want Terraform to own the full
		// set of associations; do not use both resources on the same organization.
		_, err = auth0.NewOrganizationClients(ctx, "my_org_clients", &auth0.OrganizationClientsArgs{
			OrganizationId: myOrganization.ID().ToIDOutput().ToStringOutput(),
			Clients: auth0.OrganizationClientsClientArray{
				&auth0.OrganizationClientsClientArgs{
					ClientId:           myClient.ID().ToIDOutput().ToStringOutput(),
					UseForMemberAccess: pulumi.Bool(true),
				},
				&auth0.OrganizationClientsClientArgs{
					ClientId: myOtherClient.ID().ToIDOutput().ToStringOutput(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myOrganization = new Auth0.Organization("my_organization", new()
    {
        Name = "my-organization",
        DisplayName = "My Organization",
    });

    var myClient = new Auth0.Client("my_client", new()
    {
        Name = "My Application",
    });

    var myOtherClient = new Auth0.Client("my_other_client", new()
    {
        Name = "My Other Application",
    });

    // Entitle both applications to the organization in one authoritative resource (EA only).
    // Use this instead of auth0_organization_client when you want Terraform to own the full
    // set of associations; do not use both resources on the same organization.
    var myOrgClients = new Auth0.OrganizationClients("my_org_clients", new()
    {
        OrganizationId = myOrganization.Id,
        Clients = new[]
        {
            new Auth0.Inputs.OrganizationClientsClientArgs
            {
                ClientId = myClient.Id,
                UseForMemberAccess = true,
            },
            new Auth0.Inputs.OrganizationClientsClientArgs
            {
                ClientId = myOtherClient.Id,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.Organization;
import com.pulumi.auth0.OrganizationArgs;
import com.pulumi.auth0.Client;
import com.pulumi.auth0.ClientArgs;
import com.pulumi.auth0.OrganizationClients;
import com.pulumi.auth0.OrganizationClientsArgs;
import com.pulumi.auth0.inputs.OrganizationClientsClientArgs;
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) {
        var myOrganization = new Organization("myOrganization", OrganizationArgs.builder()
            .name("my-organization")
            .displayName("My Organization")
            .build());

        var myClient = new Client("myClient", ClientArgs.builder()
            .name("My Application")
            .build());

        var myOtherClient = new Client("myOtherClient", ClientArgs.builder()
            .name("My Other Application")
            .build());

        // Entitle both applications to the organization in one authoritative resource (EA only).
        // Use this instead of auth0_organization_client when you want Terraform to own the full
        // set of associations; do not use both resources on the same organization.
        var myOrgClients = new OrganizationClients("myOrgClients", OrganizationClientsArgs.builder()
            .organizationId(myOrganization.id())
            .clients(            
                OrganizationClientsClientArgs.builder()
                    .clientId(myClient.id())
                    .useForMemberAccess(true)
                    .build(),
                OrganizationClientsClientArgs.builder()
                    .clientId(myOtherClient.id())
                    .build())
            .build());

    }
}

resources:
  myOrganization:
    type: auth0:Organization
    name: my_organization
    properties:
      name: my-organization
      displayName: My Organization
  myClient:
    type: auth0:Client
    name: my_client
    properties:
      name: My Application
  myOtherClient:
    type: auth0:Client
    name: my_other_client
    properties:
      name: My Other Application
  # Entitle both applications to the organization in one authoritative resource (EA only).
  # Use this instead of auth0_organization_client when you want Terraform to own the full
  # set of associations; do not use both resources on the same organization.
  myOrgClients:
    type: auth0:OrganizationClients
    name: my_org_clients
    properties:
      organizationId: ${myOrganization.id}
      clients:
        - clientId: ${myClient.id}
          useForMemberAccess: true
        - clientId: ${myOtherClient.id}

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

resource "auth0_organization" "my_organization" {
  name         = "my-organization"
  display_name = "My Organization"
}
resource "auth0_client" "my_client" {
  name = "My Application"
}
resource "auth0_client" "my_other_client" {
  name = "My Other Application"
}
# Entitle both applications to the organization in one authoritative resource (EA only).
# Use this instead of auth0_organization_client when you want Terraform to own the full
# set of associations; do not use both resources on the same organization.
resource "auth0_organizationclients" "my_org_clients" {
  organization_id = auth0_organization.my_organization.id
  clients {
    client_id             = auth0_client.my_client.id
    use_for_member_access = true
  }
  clients {
    client_id = auth0_client.my_other_client.id
  }
}

var organizationClientsResource = new Auth0.OrganizationClients("organizationClientsResource", new()
{
    Clients = new[]
    {
        new Auth0.Inputs.OrganizationClientsClientArgs
        {
            ClientId = "string",
            UseForMemberAccess = false,
        },
    },
    OrganizationId = "string",
});

example, err := auth0.NewOrganizationClients(ctx, "organizationClientsResource", &auth0.OrganizationClientsArgs{
	Clients: auth0.OrganizationClientsClientArray{
		&auth0.OrganizationClientsClientArgs{
			ClientId:           pulumi.String("string"),
			UseForMemberAccess: pulumi.Bool(false),
		},
	},
	OrganizationId: pulumi.String("string"),
})

resource "auth0_organization_clients" "organizationClientsResource" {
  lifecycle {
    create_before_destroy = true
  }
  clients {
    client_id             = "string"
    use_for_member_access = false
  }
  organization_id = "string"
}

var organizationClientsResource = new OrganizationClients("organizationClientsResource", OrganizationClientsArgs.builder()
    .clients(OrganizationClientsClientArgs.builder()
        .clientId("string")
        .useForMemberAccess(false)
        .build())
    .organizationId("string")
    .build());

organization_clients_resource = auth0.OrganizationClients("organizationClientsResource",
    clients=[{
        "client_id": "string",
        "use_for_member_access": False,
    }],
    organization_id="string")

const organizationClientsResource = new auth0.OrganizationClients("organizationClientsResource", {
    clients: [{
        clientId: "string",
        useForMemberAccess: false,
    }],
    organizationId: "string",
});

type: auth0:OrganizationClients
properties:
    clients:
        - clientId: string
          useForMemberAccess: false
    organizationId: string