harness.platform.GithubConnector

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

return await Deployment.RunAsync(() => 
{
    var test = new Harness.Platform.GithubConnector("test", new()
    {
        ApiAuthentication = new Harness.Platform.Inputs.GithubConnectorApiAuthenticationArgs
        {
            GithubApp = new Harness.Platform.Inputs.GithubConnectorApiAuthenticationGithubAppArgs
            {
                ApplicationId = "application_id",
                InstallationId = "installation_id",
                PrivateKeyRef = "account.secret_id",
            },
        },
        ConnectionType = "Account",
        Credentials = new Harness.Platform.Inputs.GithubConnectorCredentialsArgs
        {
            Http = new Harness.Platform.Inputs.GithubConnectorCredentialsHttpArgs
            {
                TokenRef = "account.secret_id",
                Username = "username",
            },
        },
        DelegateSelectors = new[]
        {
            "harness-delegate",
        },
        Description = "test",
        Identifier = "identifier",
        Tags = new[]
        {
            "foo:bar",
        },
        Url = "https://github.com/account",
        ValidationRepo = "some_repo",
    });

});

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.NewGithubConnector(ctx, "test", &platform.GithubConnectorArgs{
			ApiAuthentication: &platform.GithubConnectorApiAuthenticationArgs{
				GithubApp: &platform.GithubConnectorApiAuthenticationGithubAppArgs{
					ApplicationId:  pulumi.String("application_id"),
					InstallationId: pulumi.String("installation_id"),
					PrivateKeyRef:  pulumi.String("account.secret_id"),
				},
			},
			ConnectionType: pulumi.String("Account"),
			Credentials: &platform.GithubConnectorCredentialsArgs{
				Http: &platform.GithubConnectorCredentialsHttpArgs{
					TokenRef: pulumi.String("account.secret_id"),
					Username: pulumi.String("username"),
				},
			},
			DelegateSelectors: pulumi.StringArray{
				pulumi.String("harness-delegate"),
			},
			Description: pulumi.String("test"),
			Identifier:  pulumi.String("identifier"),
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
			},
			Url:            pulumi.String("https://github.com/account"),
			ValidationRepo: pulumi.String("some_repo"),
		})
		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.GithubConnector;
import com.pulumi.harness.platform.GithubConnectorArgs;
import com.pulumi.harness.platform.inputs.GithubConnectorApiAuthenticationArgs;
import com.pulumi.harness.platform.inputs.GithubConnectorApiAuthenticationGithubAppArgs;
import com.pulumi.harness.platform.inputs.GithubConnectorCredentialsArgs;
import com.pulumi.harness.platform.inputs.GithubConnectorCredentialsHttpArgs;
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 GithubConnector("test", GithubConnectorArgs.builder()        
            .apiAuthentication(GithubConnectorApiAuthenticationArgs.builder()
                .githubApp(GithubConnectorApiAuthenticationGithubAppArgs.builder()
                    .applicationId("application_id")
                    .installationId("installation_id")
                    .privateKeyRef("account.secret_id")
                    .build())
                .build())
            .connectionType("Account")
            .credentials(GithubConnectorCredentialsArgs.builder()
                .http(GithubConnectorCredentialsHttpArgs.builder()
                    .tokenRef("account.secret_id")
                    .username("username")
                    .build())
                .build())
            .delegateSelectors("harness-delegate")
            .description("test")
            .identifier("identifier")
            .tags("foo:bar")
            .url("https://github.com/account")
            .validationRepo("some_repo")
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_harness as harness

test = harness.platform.GithubConnector("test",
    api_authentication=harness.platform.GithubConnectorApiAuthenticationArgs(
        github_app=harness.platform.GithubConnectorApiAuthenticationGithubAppArgs(
            application_id="application_id",
            installation_id="installation_id",
            private_key_ref="account.secret_id",
        ),
    ),
    connection_type="Account",
    credentials=harness.platform.GithubConnectorCredentialsArgs(
        http=harness.platform.GithubConnectorCredentialsHttpArgs(
            token_ref="account.secret_id",
            username="username",
        ),
    ),
    delegate_selectors=["harness-delegate"],
    description="test",
    identifier="identifier",
    tags=["foo:bar"],
    url="https://github.com/account",
    validation_repo="some_repo")

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

const test = new harness.platform.GithubConnector("test", {
    apiAuthentication: {
        githubApp: {
            applicationId: "application_id",
            installationId: "installation_id",
            privateKeyRef: "account.secret_id",
        },
    },
    connectionType: "Account",
    credentials: {
        http: {
            tokenRef: "account.secret_id",
            username: "username",
        },
    },
    delegateSelectors: ["harness-delegate"],
    description: "test",
    identifier: "identifier",
    tags: ["foo:bar"],
    url: "https://github.com/account",
    validationRepo: "some_repo",
});

resources:
  test:
    type: harness:platform:GithubConnector
    properties:
      apiAuthentication:
        githubApp:
          applicationId: application_id
          installationId: installation_id
          privateKeyRef: account.secret_id
      connectionType: Account
      credentials:
        http:
          tokenRef: account.secret_id
          username: username
      delegateSelectors:
        - harness-delegate
      description: test
      identifier: identifier
      tags:
        - foo:bar
      url: https://github.com/account
      validationRepo: some_repo