harness.platform.ServiceNowConnector

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Harness = Lbrlabs.PulumiPackage.Harness;

return await Deployment.RunAsync(() => 
{
    // Credential type AdfsClientCredentialsWithCertificate
    var test = new Harness.Platform.ServiceNowConnector("test", new()
    {
        Auth = new Harness.Platform.Inputs.ServiceNowConnectorAuthArgs
        {
            Adfs = new Harness.Platform.Inputs.ServiceNowConnectorAuthAdfsArgs
            {
                AdfsUrl = "https://adfs_url.com",
                CertificateRef = "account.certificate_ref",
                ClientIdRef = "account.client_id_ref",
                PrivateKeyRef = "account.private_key_ref}",
                ResourceIdRef = "account.resource_id_ref",
            },
            AuthType = "AdfsClientCredentialsWithCertificate",
        },
        DelegateSelectors = new[]
        {
            "harness-delegate",
        },
        Description = "test",
        Identifier = "identifier",
        ServiceNowUrl = "https://servicenow.com",
        Tags = new[]
        {
            "foo:bar",
        },
    });

});

package main

import (
	"github.com/lbrlabs/pulumi-harness/sdk/go/harness/platform"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := platform.NewServiceNowConnector(ctx, "test", &platform.ServiceNowConnectorArgs{
			Auth: &platform.ServiceNowConnectorAuthArgs{
				Adfs: &platform.ServiceNowConnectorAuthAdfsArgs{
					AdfsUrl:        pulumi.String("https://adfs_url.com"),
					CertificateRef: pulumi.String("account.certificate_ref"),
					ClientIdRef:    pulumi.String("account.client_id_ref"),
					PrivateKeyRef:  pulumi.String("account.private_key_ref}"),
					ResourceIdRef:  pulumi.String("account.resource_id_ref"),
				},
				AuthType: pulumi.String("AdfsClientCredentialsWithCertificate"),
			},
			DelegateSelectors: pulumi.StringArray{
				pulumi.String("harness-delegate"),
			},
			Description:   pulumi.String("test"),
			Identifier:    pulumi.String("identifier"),
			ServiceNowUrl: pulumi.String("https://servicenow.com"),
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.platform.ServiceNowConnector;
import com.pulumi.harness.platform.ServiceNowConnectorArgs;
import com.pulumi.harness.platform.inputs.ServiceNowConnectorAuthArgs;
import com.pulumi.harness.platform.inputs.ServiceNowConnectorAuthAdfsArgs;
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 test = new ServiceNowConnector("test", ServiceNowConnectorArgs.builder()        
            .auth(ServiceNowConnectorAuthArgs.builder()
                .adfs(ServiceNowConnectorAuthAdfsArgs.builder()
                    .adfsUrl("https://adfs_url.com")
                    .certificateRef("account.certificate_ref")
                    .clientIdRef("account.client_id_ref")
                    .privateKeyRef("account.private_key_ref}")
                    .resourceIdRef("account.resource_id_ref")
                    .build())
                .authType("AdfsClientCredentialsWithCertificate")
                .build())
            .delegateSelectors("harness-delegate")
            .description("test")
            .identifier("identifier")
            .serviceNowUrl("https://servicenow.com")
            .tags("foo:bar")
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_harness as harness

# Credential type AdfsClientCredentialsWithCertificate
test = harness.platform.ServiceNowConnector("test",
    auth=harness.platform.ServiceNowConnectorAuthArgs(
        adfs=harness.platform.ServiceNowConnectorAuthAdfsArgs(
            adfs_url="https://adfs_url.com",
            certificate_ref="account.certificate_ref",
            client_id_ref="account.client_id_ref",
            private_key_ref="account.private_key_ref}",
            resource_id_ref="account.resource_id_ref",
        ),
        auth_type="AdfsClientCredentialsWithCertificate",
    ),
    delegate_selectors=["harness-delegate"],
    description="test",
    identifier="identifier",
    service_now_url="https://servicenow.com",
    tags=["foo:bar"])

import * as pulumi from "@pulumi/pulumi";
import * as harness from "@lbrlabs/pulumi-harness";

// Credential type AdfsClientCredentialsWithCertificate
const test = new harness.platform.ServiceNowConnector("test", {
    auth: {
        adfs: {
            adfsUrl: "https://adfs_url.com",
            certificateRef: "account.certificate_ref",
            clientIdRef: "account.client_id_ref",
            privateKeyRef: "account.private_key_ref}",
            resourceIdRef: "account.resource_id_ref",
        },
        authType: "AdfsClientCredentialsWithCertificate",
    },
    delegateSelectors: ["harness-delegate"],
    description: "test",
    identifier: "identifier",
    serviceNowUrl: "https://servicenow.com",
    tags: ["foo:bar"],
});

resources:
  # Credential type AdfsClientCredentialsWithCertificate
  test:
    type: harness:platform:ServiceNowConnector
    properties:
      auth:
        adfs:
          adfsUrl: https://adfs_url.com
          certificateRef: account.certificate_ref
          clientIdRef: account.client_id_ref
          privateKeyRef: account.private_key_ref}
          resourceIdRef: account.resource_id_ref
        authType: AdfsClientCredentialsWithCertificate
      delegateSelectors:
        - harness-delegate
      description: test
      identifier: identifier
      serviceNowUrl: https://servicenow.com
      tags:
        - foo:bar