dbtcloud.AuthProvider

import * as pulumi from "@pulumi/pulumi";
import * as dbtcloud from "@pulumi/dbtcloud";
import * as std from "@pulumi/std";

const config = new pulumi.Config();
const samlCert = config.require("samlCert");
const saml = new dbtcloud.AuthProvider("saml", {
    type: "saml",
    entityId: "https://your-idp.example.com/metadata",
    ssoUrl: "https://your-idp.example.com/sso/saml",
    certWo: samlCert,
    certWoVersion: 1,
});
export const loginUrl = saml.loginUrl;
// SAML — all optional fields
const samlFull = new dbtcloud.AuthProvider("saml_full", {
    type: "saml",
    entityId: "https://your-idp.example.com/metadata",
    ssoUrl: "https://your-idp.example.com/sso/saml",
    cert: std.file({
        input: "idp-cert.pem",
    }).then(invoke => invoke.result),
    signRequest: true,
    attributeMap: JSON.stringify({
        email: "nameID",
        first_name: "firstName",
        last_name: "lastName",
    }),
    allowPasswordBackdoor: false,
});
// Okta (identical to SAML, different type value)
const okta = new dbtcloud.AuthProvider("okta", {
    type: "okta",
    entityId: "http://www.okta.com/<okta_app_id>",
    ssoUrl: "https://<your-org>.okta.com/app/<app_path>/sso/saml",
    certWo: samlCert,
    certWoVersion: 1,
});
const azureClientSecret = config.require("azureClientSecret");
const azureSingleTenant = new dbtcloud.AuthProvider("azure_single_tenant", {
    type: "azure_single_tenant",
    clientId: "00000000-0000-0000-0000-000000000000",
    tenantId: "11111111-1111-1111-1111-111111111111",
    clientSecretWo: azureClientSecret,
    clientSecretWoVersion: 1,
    domain: "acme.com",
    includeIndirectGroups: true,
    maxGroupsToRetrieve: 500,
});
// Azure AD — multi tenant (no tenant_id required)
const azureMultiTenant = new dbtcloud.AuthProvider("azure_multi_tenant", {
    type: "azure_multi_tenant",
    clientId: "00000000-0000-0000-0000-000000000000",
    clientSecretWo: azureClientSecret,
    clientSecretWoVersion: 1,
});
// Azure Active Directory
const azureActiveDirectory = new dbtcloud.AuthProvider("azure_active_directory", {
    type: "azure_active_directory",
    clientId: "00000000-0000-0000-0000-000000000000",
    tenantId: "11111111-1111-1111-1111-111111111111",
    clientSecretWo: azureClientSecret,
    clientSecretWoVersion: 1,
    domain: "acme.com",
});
const gsuiteClientSecret = config.require("gsuiteClientSecret");
const gsuite = new dbtcloud.AuthProvider("gsuite", {
    type: "gsuite",
    clientId: "000000000000-xxxx.apps.googleusercontent.com",
    clientSecretWo: gsuiteClientSecret,
    clientSecretWoVersion: 1,
    adminRefreshToken: "<oauth-refresh-token>",
    domain: "acme.com",
    gsuiteAdminId: "admin@acme.com",
});

import pulumi
import json
import pulumi_dbtcloud as dbtcloud
import pulumi_std as std

config = pulumi.Config()
saml_cert = config.require("samlCert")
saml = dbtcloud.AuthProvider("saml",
    type="saml",
    entity_id="https://your-idp.example.com/metadata",
    sso_url="https://your-idp.example.com/sso/saml",
    cert_wo=saml_cert,
    cert_wo_version=1)
pulumi.export("loginUrl", saml.login_url)
# SAML — all optional fields
saml_full = dbtcloud.AuthProvider("saml_full",
    type="saml",
    entity_id="https://your-idp.example.com/metadata",
    sso_url="https://your-idp.example.com/sso/saml",
    cert=std.file(input="idp-cert.pem").result,
    sign_request=True,
    attribute_map=json.dumps({
        "email": "nameID",
        "first_name": "firstName",
        "last_name": "lastName",
    }),
    allow_password_backdoor=False)
# Okta (identical to SAML, different type value)
okta = dbtcloud.AuthProvider("okta",
    type="okta",
    entity_id="http://www.okta.com/<okta_app_id>",
    sso_url="https://<your-org>.okta.com/app/<app_path>/sso/saml",
    cert_wo=saml_cert,
    cert_wo_version=1)
azure_client_secret = config.require("azureClientSecret")
azure_single_tenant = dbtcloud.AuthProvider("azure_single_tenant",
    type="azure_single_tenant",
    client_id="00000000-0000-0000-0000-000000000000",
    tenant_id="11111111-1111-1111-1111-111111111111",
    client_secret_wo=azure_client_secret,
    client_secret_wo_version=1,
    domain="acme.com",
    include_indirect_groups=True,
    max_groups_to_retrieve=500)
# Azure AD — multi tenant (no tenant_id required)
azure_multi_tenant = dbtcloud.AuthProvider("azure_multi_tenant",
    type="azure_multi_tenant",
    client_id="00000000-0000-0000-0000-000000000000",
    client_secret_wo=azure_client_secret,
    client_secret_wo_version=1)
# Azure Active Directory
azure_active_directory = dbtcloud.AuthProvider("azure_active_directory",
    type="azure_active_directory",
    client_id="00000000-0000-0000-0000-000000000000",
    tenant_id="11111111-1111-1111-1111-111111111111",
    client_secret_wo=azure_client_secret,
    client_secret_wo_version=1,
    domain="acme.com")
gsuite_client_secret = config.require("gsuiteClientSecret")
gsuite = dbtcloud.AuthProvider("gsuite",
    type="gsuite",
    client_id="000000000000-xxxx.apps.googleusercontent.com",
    client_secret_wo=gsuite_client_secret,
    client_secret_wo_version=1,
    admin_refresh_token="<oauth-refresh-token>",
    domain="acme.com",
    gsuite_admin_id="admin@acme.com")

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-dbtcloud/sdk/go/dbtcloud"
	"github.com/pulumi/pulumi-std/sdk/v2/go/std"
	"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, "")
		samlCert := cfg.Require("samlCert")
		saml, err := dbtcloud.NewAuthProvider(ctx, "saml", &dbtcloud.AuthProviderArgs{
			Type:          pulumi.String("saml"),
			EntityId:      pulumi.String("https://your-idp.example.com/metadata"),
			SsoUrl:        pulumi.String("https://your-idp.example.com/sso/saml"),
			CertWo:        pulumi.String(pulumi.String(samlCert)),
			CertWoVersion: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		ctx.Export("loginUrl", saml.LoginUrl)
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "idp-cert.pem",
		}, nil)
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"email":      "nameID",
			"first_name": "firstName",
			"last_name":  "lastName",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// SAML — all optional fields
		_, err = dbtcloud.NewAuthProvider(ctx, "saml_full", &dbtcloud.AuthProviderArgs{
			Type:                  pulumi.String("saml"),
			EntityId:              pulumi.String("https://your-idp.example.com/metadata"),
			SsoUrl:                pulumi.String("https://your-idp.example.com/sso/saml"),
			Cert:                  pulumi.String(invokeFile.Result),
			SignRequest:           pulumi.Bool(true),
			AttributeMap:          pulumi.String(pulumi.String(json0)),
			AllowPasswordBackdoor: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// Okta (identical to SAML, different type value)
		_, err = dbtcloud.NewAuthProvider(ctx, "okta", &dbtcloud.AuthProviderArgs{
			Type:          pulumi.String("okta"),
			EntityId:      pulumi.String("http://www.okta.com/<okta_app_id>"),
			SsoUrl:        pulumi.String("https://<your-org>.okta.com/app/<app_path>/sso/saml"),
			CertWo:        pulumi.String(pulumi.String(samlCert)),
			CertWoVersion: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		azureClientSecret := cfg.Require("azureClientSecret")
		_, err = dbtcloud.NewAuthProvider(ctx, "azure_single_tenant", &dbtcloud.AuthProviderArgs{
			Type:                  pulumi.String("azure_single_tenant"),
			ClientId:              pulumi.String("00000000-0000-0000-0000-000000000000"),
			TenantId:              pulumi.String("11111111-1111-1111-1111-111111111111"),
			ClientSecretWo:        pulumi.String(pulumi.String(azureClientSecret)),
			ClientSecretWoVersion: pulumi.Int(1),
			Domain:                pulumi.String("acme.com"),
			IncludeIndirectGroups: pulumi.Bool(true),
			MaxGroupsToRetrieve:   pulumi.Int(500),
		})
		if err != nil {
			return err
		}
		// Azure AD — multi tenant (no tenant_id required)
		_, err = dbtcloud.NewAuthProvider(ctx, "azure_multi_tenant", &dbtcloud.AuthProviderArgs{
			Type:                  pulumi.String("azure_multi_tenant"),
			ClientId:              pulumi.String("00000000-0000-0000-0000-000000000000"),
			ClientSecretWo:        pulumi.String(pulumi.String(azureClientSecret)),
			ClientSecretWoVersion: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		// Azure Active Directory
		_, err = dbtcloud.NewAuthProvider(ctx, "azure_active_directory", &dbtcloud.AuthProviderArgs{
			Type:                  pulumi.String("azure_active_directory"),
			ClientId:              pulumi.String("00000000-0000-0000-0000-000000000000"),
			TenantId:              pulumi.String("11111111-1111-1111-1111-111111111111"),
			ClientSecretWo:        pulumi.String(pulumi.String(azureClientSecret)),
			ClientSecretWoVersion: pulumi.Int(1),
			Domain:                pulumi.String("acme.com"),
		})
		if err != nil {
			return err
		}
		gsuiteClientSecret := cfg.Require("gsuiteClientSecret")
		_, err = dbtcloud.NewAuthProvider(ctx, "gsuite", &dbtcloud.AuthProviderArgs{
			Type:                  pulumi.String("gsuite"),
			ClientId:              pulumi.String("000000000000-xxxx.apps.googleusercontent.com"),
			ClientSecretWo:        pulumi.String(pulumi.String(gsuiteClientSecret)),
			ClientSecretWoVersion: pulumi.Int(1),
			AdminRefreshToken:     pulumi.String("<oauth-refresh-token>"),
			Domain:                pulumi.String("acme.com"),
			GsuiteAdminId:         pulumi.String("admin@acme.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using DbtCloud = Pulumi.DbtCloud;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var samlCert = config.Require("samlCert");
    var saml = new DbtCloud.AuthProvider("saml", new()
    {
        Type = "saml",
        EntityId = "https://your-idp.example.com/metadata",
        SsoUrl = "https://your-idp.example.com/sso/saml",
        CertWo = samlCert,
        CertWoVersion = 1,
    });

    // SAML — all optional fields
    var samlFull = new DbtCloud.AuthProvider("saml_full", new()
    {
        Type = "saml",
        EntityId = "https://your-idp.example.com/metadata",
        SsoUrl = "https://your-idp.example.com/sso/saml",
        Cert = Std.File.Invoke(new()
        {
            Input = "idp-cert.pem",
        }).Apply(invoke => invoke.Result),
        SignRequest = true,
        AttributeMap = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["email"] = "nameID",
            ["first_name"] = "firstName",
            ["last_name"] = "lastName",
        }),
        AllowPasswordBackdoor = false,
    });

    // Okta (identical to SAML, different type value)
    var okta = new DbtCloud.AuthProvider("okta", new()
    {
        Type = "okta",
        EntityId = "http://www.okta.com/<okta_app_id>",
        SsoUrl = "https://<your-org>.okta.com/app/<app_path>/sso/saml",
        CertWo = samlCert,
        CertWoVersion = 1,
    });

    var azureClientSecret = config.Require("azureClientSecret");
    var azureSingleTenant = new DbtCloud.AuthProvider("azure_single_tenant", new()
    {
        Type = "azure_single_tenant",
        ClientId = "00000000-0000-0000-0000-000000000000",
        TenantId = "11111111-1111-1111-1111-111111111111",
        ClientSecretWo = azureClientSecret,
        ClientSecretWoVersion = 1,
        Domain = "acme.com",
        IncludeIndirectGroups = true,
        MaxGroupsToRetrieve = 500,
    });

    // Azure AD — multi tenant (no tenant_id required)
    var azureMultiTenant = new DbtCloud.AuthProvider("azure_multi_tenant", new()
    {
        Type = "azure_multi_tenant",
        ClientId = "00000000-0000-0000-0000-000000000000",
        ClientSecretWo = azureClientSecret,
        ClientSecretWoVersion = 1,
    });

    // Azure Active Directory
    var azureActiveDirectory = new DbtCloud.AuthProvider("azure_active_directory", new()
    {
        Type = "azure_active_directory",
        ClientId = "00000000-0000-0000-0000-000000000000",
        TenantId = "11111111-1111-1111-1111-111111111111",
        ClientSecretWo = azureClientSecret,
        ClientSecretWoVersion = 1,
        Domain = "acme.com",
    });

    var gsuiteClientSecret = config.Require("gsuiteClientSecret");
    var gsuite = new DbtCloud.AuthProvider("gsuite", new()
    {
        Type = "gsuite",
        ClientId = "000000000000-xxxx.apps.googleusercontent.com",
        ClientSecretWo = gsuiteClientSecret,
        ClientSecretWoVersion = 1,
        AdminRefreshToken = "<oauth-refresh-token>",
        Domain = "acme.com",
        GsuiteAdminId = "admin@acme.com",
    });

    return new Dictionary<string, object?>
    {
        ["loginUrl"] = saml.LoginUrl,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dbtcloud.AuthProvider;
import com.pulumi.dbtcloud.AuthProviderArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.FileArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        final var config = ctx.config();
        final var samlCert = config.require("samlCert");
        var saml = new AuthProvider("saml", AuthProviderArgs.builder()
            .type("saml")
            .entityId("https://your-idp.example.com/metadata")
            .ssoUrl("https://your-idp.example.com/sso/saml")
            .certWo(samlCert)
            .certWoVersion(1)
            .build());

        ctx.export("loginUrl", saml.loginUrl());
        // SAML — all optional fields
        var samlFull = new AuthProvider("samlFull", AuthProviderArgs.builder()
            .type("saml")
            .entityId("https://your-idp.example.com/metadata")
            .ssoUrl("https://your-idp.example.com/sso/saml")
            .cert(StdFunctions.file(FileArgs.builder()
                .input("idp-cert.pem")
                .build()).result())
            .signRequest(true)
            .attributeMap(serializeJson(
                jsonObject(
                    jsonProperty("email", "nameID"),
                    jsonProperty("first_name", "firstName"),
                    jsonProperty("last_name", "lastName")
                )))
            .allowPasswordBackdoor(false)
            .build());

        // Okta (identical to SAML, different type value)
        var okta = new AuthProvider("okta", AuthProviderArgs.builder()
            .type("okta")
            .entityId("http://www.okta.com/<okta_app_id>")
            .ssoUrl("https://<your-org>.okta.com/app/<app_path>/sso/saml")
            .certWo(samlCert)
            .certWoVersion(1)
            .build());

        final var azureClientSecret = config.require("azureClientSecret");
        var azureSingleTenant = new AuthProvider("azureSingleTenant", AuthProviderArgs.builder()
            .type("azure_single_tenant")
            .clientId("00000000-0000-0000-0000-000000000000")
            .tenantId("11111111-1111-1111-1111-111111111111")
            .clientSecretWo(azureClientSecret)
            .clientSecretWoVersion(1)
            .domain("acme.com")
            .includeIndirectGroups(true)
            .maxGroupsToRetrieve(500)
            .build());

        // Azure AD — multi tenant (no tenant_id required)
        var azureMultiTenant = new AuthProvider("azureMultiTenant", AuthProviderArgs.builder()
            .type("azure_multi_tenant")
            .clientId("00000000-0000-0000-0000-000000000000")
            .clientSecretWo(azureClientSecret)
            .clientSecretWoVersion(1)
            .build());

        // Azure Active Directory
        var azureActiveDirectory = new AuthProvider("azureActiveDirectory", AuthProviderArgs.builder()
            .type("azure_active_directory")
            .clientId("00000000-0000-0000-0000-000000000000")
            .tenantId("11111111-1111-1111-1111-111111111111")
            .clientSecretWo(azureClientSecret)
            .clientSecretWoVersion(1)
            .domain("acme.com")
            .build());

        final var gsuiteClientSecret = config.require("gsuiteClientSecret");
        var gsuite = new AuthProvider("gsuite", AuthProviderArgs.builder()
            .type("gsuite")
            .clientId("000000000000-xxxx.apps.googleusercontent.com")
            .clientSecretWo(gsuiteClientSecret)
            .clientSecretWoVersion(1)
            .adminRefreshToken("<oauth-refresh-token>")
            .domain("acme.com")
            .gsuiteAdminId("admin@acme.com")
            .build());

    }
}

configuration:
  # SAML — write-only cert (recommended, not stored in state)
  # //
  # // Requires Terraform >= 1.11 for write-only attribute support.
  # // Bump cert_wo_version to rotate the cert without recreating the resource.
  samlCert:
    type: string
  # Azure AD — single tenant
  azureClientSecret:
    type: string
  # Google Workspace
  gsuiteClientSecret:
    type: string
resources:
  saml:
    type: dbtcloud:AuthProvider
    properties:
      type: saml
      entityId: https://your-idp.example.com/metadata
      ssoUrl: https://your-idp.example.com/sso/saml
      certWo: ${samlCert}
      certWoVersion: 1
  # SAML — all optional fields
  samlFull:
    type: dbtcloud:AuthProvider
    name: saml_full
    properties:
      type: saml
      entityId: https://your-idp.example.com/metadata
      ssoUrl: https://your-idp.example.com/sso/saml
      cert:
        fn::invoke:
          function: std:file
          arguments:
            input: idp-cert.pem
          return: result
      signRequest: true
      attributeMap:
        fn::toJSON:
          email: nameID
          first_name: firstName
          last_name: lastName
      allowPasswordBackdoor: false
  # Okta (identical to SAML, different type value)
  okta:
    type: dbtcloud:AuthProvider
    properties:
      type: okta
      entityId: http://www.okta.com/<okta_app_id>
      ssoUrl: https://<your-org>.okta.com/app/<app_path>/sso/saml
      certWo: ${samlCert}
      certWoVersion: 1
  azureSingleTenant:
    type: dbtcloud:AuthProvider
    name: azure_single_tenant
    properties:
      type: azure_single_tenant
      clientId: 00000000-0000-0000-0000-000000000000
      tenantId: 11111111-1111-1111-1111-111111111111
      clientSecretWo: ${azureClientSecret}
      clientSecretWoVersion: 1
      domain: acme.com
      includeIndirectGroups: true
      maxGroupsToRetrieve: 500
  # Azure AD — multi tenant (no tenant_id required)
  azureMultiTenant:
    type: dbtcloud:AuthProvider
    name: azure_multi_tenant
    properties:
      type: azure_multi_tenant
      clientId: 00000000-0000-0000-0000-000000000000
      clientSecretWo: ${azureClientSecret}
      clientSecretWoVersion: 1
  # Azure Active Directory
  azureActiveDirectory:
    type: dbtcloud:AuthProvider
    name: azure_active_directory
    properties:
      type: azure_active_directory
      clientId: 00000000-0000-0000-0000-000000000000
      tenantId: 11111111-1111-1111-1111-111111111111
      clientSecretWo: ${azureClientSecret}
      clientSecretWoVersion: 1
      domain: acme.com
  gsuite:
    type: dbtcloud:AuthProvider
    properties:
      type: gsuite
      clientId: 000000000000-xxxx.apps.googleusercontent.com
      clientSecretWo: ${gsuiteClientSecret}
      clientSecretWoVersion: 1
      adminRefreshToken: <oauth-refresh-token>
      domain: acme.com
      gsuiteAdminId: admin@acme.com
outputs:
  loginUrl: ${saml.loginUrl}

var authProviderResource = new DbtCloud.AuthProvider("authProviderResource", new()
{
    Type = "string",
    ClientSecretWoVersion = 0,
    AttributeMap = "string",
    AuthorizationUrl = "string",
    Cert = "string",
    CertWo = "string",
    CertWoVersion = 0,
    ClientId = "string",
    ClientSecret = "string",
    AdminRefreshToken = "string",
    ClientSecretWo = "string",
    GsuiteAdminId = "string",
    EntityId = "string",
    Domain = "string",
    IncludeIndirectGroups = false,
    MaxGroupsToRetrieve = 0,
    SignRequest = false,
    Slug = "string",
    SsoUrl = "string",
    TenantId = "string",
    AllowPasswordBackdoor = false,
});

example, err := dbtcloud.NewAuthProvider(ctx, "authProviderResource", &dbtcloud.AuthProviderArgs{
	Type:                  pulumi.String("string"),
	ClientSecretWoVersion: pulumi.Int(0),
	AttributeMap:          pulumi.String("string"),
	AuthorizationUrl:      pulumi.String("string"),
	Cert:                  pulumi.String("string"),
	CertWo:                pulumi.String("string"),
	CertWoVersion:         pulumi.Int(0),
	ClientId:              pulumi.String("string"),
	ClientSecret:          pulumi.String("string"),
	AdminRefreshToken:     pulumi.String("string"),
	ClientSecretWo:        pulumi.String("string"),
	GsuiteAdminId:         pulumi.String("string"),
	EntityId:              pulumi.String("string"),
	Domain:                pulumi.String("string"),
	IncludeIndirectGroups: pulumi.Bool(false),
	MaxGroupsToRetrieve:   pulumi.Int(0),
	SignRequest:           pulumi.Bool(false),
	Slug:                  pulumi.String("string"),
	SsoUrl:                pulumi.String("string"),
	TenantId:              pulumi.String("string"),
	AllowPasswordBackdoor: pulumi.Bool(false),
})

resource "dbtcloud_authprovider" "authProviderResource" {
  type                     = "string"
  client_secret_wo_version = 0
  attribute_map            = "string"
  authorization_url        = "string"
  cert                     = "string"
  cert_wo                  = "string"
  cert_wo_version          = 0
  client_id                = "string"
  client_secret            = "string"
  admin_refresh_token      = "string"
  client_secret_wo         = "string"
  gsuite_admin_id          = "string"
  entity_id                = "string"
  domain                   = "string"
  include_indirect_groups  = false
  max_groups_to_retrieve   = 0
  sign_request             = false
  slug                     = "string"
  sso_url                  = "string"
  tenant_id                = "string"
  allow_password_backdoor  = false
}

var authProviderResource = new AuthProvider("authProviderResource", AuthProviderArgs.builder()
    .type("string")
    .clientSecretWoVersion(0)
    .attributeMap("string")
    .authorizationUrl("string")
    .cert("string")
    .certWo("string")
    .certWoVersion(0)
    .clientId("string")
    .clientSecret("string")
    .adminRefreshToken("string")
    .clientSecretWo("string")
    .gsuiteAdminId("string")
    .entityId("string")
    .domain("string")
    .includeIndirectGroups(false)
    .maxGroupsToRetrieve(0)
    .signRequest(false)
    .slug("string")
    .ssoUrl("string")
    .tenantId("string")
    .allowPasswordBackdoor(false)
    .build());

auth_provider_resource = dbtcloud.AuthProvider("authProviderResource",
    type="string",
    client_secret_wo_version=0,
    attribute_map="string",
    authorization_url="string",
    cert="string",
    cert_wo="string",
    cert_wo_version=0,
    client_id="string",
    client_secret="string",
    admin_refresh_token="string",
    client_secret_wo="string",
    gsuite_admin_id="string",
    entity_id="string",
    domain="string",
    include_indirect_groups=False,
    max_groups_to_retrieve=0,
    sign_request=False,
    slug="string",
    sso_url="string",
    tenant_id="string",
    allow_password_backdoor=False)

const authProviderResource = new dbtcloud.AuthProvider("authProviderResource", {
    type: "string",
    clientSecretWoVersion: 0,
    attributeMap: "string",
    authorizationUrl: "string",
    cert: "string",
    certWo: "string",
    certWoVersion: 0,
    clientId: "string",
    clientSecret: "string",
    adminRefreshToken: "string",
    clientSecretWo: "string",
    gsuiteAdminId: "string",
    entityId: "string",
    domain: "string",
    includeIndirectGroups: false,
    maxGroupsToRetrieve: 0,
    signRequest: false,
    slug: "string",
    ssoUrl: "string",
    tenantId: "string",
    allowPasswordBackdoor: false,
});

type: dbtcloud:AuthProvider
properties:
    adminRefreshToken: string
    allowPasswordBackdoor: false
    attributeMap: string
    authorizationUrl: string
    cert: string
    certWo: string
    certWoVersion: 0
    clientId: string
    clientSecret: string
    clientSecretWo: string
    clientSecretWoVersion: 0
    domain: string
    entityId: string
    gsuiteAdminId: string
    includeIndirectGroups: false
    maxGroupsToRetrieve: 0
    signRequest: false
    slug: string
    ssoUrl: string
    tenantId: string
    type: string