diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 8309d90..60dda98 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -54,14 +54,7 @@ RUN apt-get install -y python3 && \ apt-get install -y python3-setuptools # Install .NET -RUN wget https://packages.microsoft.com/config/ubuntu/22.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb && \ - dpkg -i packages-microsoft-prod.deb && \ - rm packages-microsoft-prod.deb - -RUN apt-get update && \ - apt-get install -y apt-transport-https && \ - apt-get update && \ - apt-get install -y dotnet-sdk-6.0 +RUN apt-get install -y dotnet-sdk-6.0 # Install Pulumi RUN curl -fsSL https://get.pulumi.com | sh diff --git a/.github/workflows/build-library.yml b/.github/workflows/build-library.yml new file mode 100644 index 0000000..c69cfc9 --- /dev/null +++ b/.github/workflows/build-library.yml @@ -0,0 +1,58 @@ +name: Build library + +on: { push: { branches-ignore: [future, main] } } + +concurrency: + group: build-library-${{ github.ref }} + cancel-in-progress: true + +jobs: + build-library: + name: Build library + runs-on: ubuntu-latest + container: golang:1.21-alpine + steps: + - name: Install build dependencies + run: | + apk add --no-cache alpine-sdk git bash npm python3 py3-pip + + - name: Install yarn + run: npm install --global yarn + + - name: Setup Dotnet + uses: actions/setup-dotnet@v3 + with: + dotnet-version: 6 + + - name: Check out repository code + uses: actions/checkout@main + + - name: Treat repo as safe + run: git config --global --add safe.directory /__w/pulumi-spacelift/pulumi-spacelift + + - name: Remove Pulumi directory + run: rm -rf /github/home/.pulumi + + - name: Install pulumictl + uses: jaxxstorm/action-install-gh-release@v1 + with: + repo: pulumi/pulumictl + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + - name: Install pulumi + uses: pulumi/actions@v4 + + - name: Tag version + run: git tag -d `git tag | grep -E '.'` && git tag v0.0.0 + + - name: Print version + run: pulumictl get version + + - name: Build SDKs + run: make build_sdks + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + - name: Check if sdk is up to date + run: git diff --exit-code ./ diff --git a/.github/workflows/build-provider.yml b/.github/workflows/build-provider.yml index df7f91f..837ec65 100644 --- a/.github/workflows/build-provider.yml +++ b/.github/workflows/build-provider.yml @@ -44,4 +44,4 @@ jobs: - name: Build provider run: make provider env: - PROVIDER_OS: ${{ matrix.provider_os }} + PROVIDER_OS: ${{ matrix.provider_os }} \ No newline at end of file diff --git a/.github/workflows/library-deployment.yml b/.github/workflows/library-deployment.yml index 82450af..92c8a2a 100644 --- a/.github/workflows/library-deployment.yml +++ b/.github/workflows/library-deployment.yml @@ -50,7 +50,7 @@ jobs: - name: Setup DotNet uses: actions/setup-dotnet@v3 with: - dotnet-version: 3.1.301 + dotnet-version: 6 - name: Setup DotNet ICU run: sudo apt-get update && sudo apt-get install -y icu-devtools diff --git a/Makefile b/Makefile index f8539b4..8d4818b 100644 --- a/Makefile +++ b/Makefile @@ -65,7 +65,6 @@ build_nodejs:: install_plugins tfgen # build the node sdk cd sdk/nodejs/ && \ yarn install && \ yarn run tsc && \ - cp -R scripts/ bin && \ cp ../../README.md ../../LICENSE package.json yarn.lock ./bin/ && \ sed -i.bak -e "s/\$${VERSION}/$(VERSION)/g" ./bin/package.json diff --git a/sdk/dotnet/AwsIntegration.cs b/sdk/dotnet/AwsIntegration.cs index c088a85..c78781f 100644 --- a/sdk/dotnet/AwsIntegration.cs +++ b/sdk/dotnet/AwsIntegration.cs @@ -12,7 +12,7 @@ namespace Pulumi.Spacelift /// /// `spacelift.AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. /// - /// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-$suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + /// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@$suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. /// /// ## Import /// diff --git a/sdk/dotnet/AwsIntegrationAttachment.cs b/sdk/dotnet/AwsIntegrationAttachment.cs index a8d5bc1..6cc6ee6 100644 --- a/sdk/dotnet/AwsIntegrationAttachment.cs +++ b/sdk/dotnet/AwsIntegrationAttachment.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/AzureIntegration.cs b/sdk/dotnet/AzureIntegration.cs index 6388024..9e969f6 100644 --- a/sdk/dotnet/AzureIntegration.cs +++ b/sdk/dotnet/AzureIntegration.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/AzureIntegrationAttachment.cs b/sdk/dotnet/AzureIntegrationAttachment.cs index 67737d4..974f797 100644 --- a/sdk/dotnet/AzureIntegrationAttachment.cs +++ b/sdk/dotnet/AzureIntegrationAttachment.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/Blueprint.cs b/sdk/dotnet/Blueprint.cs new file mode 100644 index 0000000..e6ac32b --- /dev/null +++ b/sdk/dotnet/Blueprint.cs @@ -0,0 +1,195 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + [SpaceliftResourceType("spacelift:index/blueprint:Blueprint")] + public partial class Blueprint : global::Pulumi.CustomResource + { + /// + /// Description of the blueprint + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + /// + /// Labels of the blueprint + /// + [Output("labels")] + public Output> Labels { get; private set; } = null!; + + /// + /// Name of the blueprint + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// ID of the space the blueprint is in + /// + [Output("space")] + public Output Space { get; private set; } = null!; + + /// + /// State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + /// + [Output("state")] + public Output State { get; private set; } = null!; + + /// + /// Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + /// + [Output("template")] + public Output Template { get; private set; } = null!; + + + /// + /// Create a Blueprint resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public Blueprint(string name, BlueprintArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/blueprint:Blueprint", name, args ?? new BlueprintArgs(), MakeResourceOptions(options, "")) + { + } + + private Blueprint(string name, Input id, BlueprintState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/blueprint:Blueprint", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing Blueprint resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static Blueprint Get(string name, Input id, BlueprintState? state = null, CustomResourceOptions? options = null) + { + return new Blueprint(name, id, state, options); + } + } + + public sealed class BlueprintArgs : global::Pulumi.ResourceArgs + { + /// + /// Description of the blueprint + /// + [Input("description")] + public Input? Description { get; set; } + + [Input("labels")] + private InputList? _labels; + + /// + /// Labels of the blueprint + /// + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + + /// + /// Name of the blueprint + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// ID of the space the blueprint is in + /// + [Input("space", required: true)] + public Input Space { get; set; } = null!; + + /// + /// State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + /// + [Input("state", required: true)] + public Input State { get; set; } = null!; + + /// + /// Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + /// + [Input("template")] + public Input? Template { get; set; } + + public BlueprintArgs() + { + } + public static new BlueprintArgs Empty => new BlueprintArgs(); + } + + public sealed class BlueprintState : global::Pulumi.ResourceArgs + { + /// + /// Description of the blueprint + /// + [Input("description")] + public Input? Description { get; set; } + + [Input("labels")] + private InputList? _labels; + + /// + /// Labels of the blueprint + /// + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + + /// + /// Name of the blueprint + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// ID of the space the blueprint is in + /// + [Input("space")] + public Input? Space { get; set; } + + /// + /// State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + /// + [Input("state")] + public Input? State { get; set; } + + /// + /// Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + /// + [Input("template")] + public Input? Template { get; set; } + + public BlueprintState() + { + } + public static new BlueprintState Empty => new BlueprintState(); + } +} diff --git a/sdk/dotnet/Config/Config.cs b/sdk/dotnet/Config/Config.cs index f63589b..5cdce82 100644 --- a/sdk/dotnet/Config/Config.cs +++ b/sdk/dotnet/Config/Config.cs @@ -8,7 +8,7 @@ namespace Pulumi.Spacelift { public static class Config { - [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "IDE1006", Justification = + [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "IDE1006", Justification = "Double underscore prefix used to avoid conflicts with variable names.")] private sealed class __Value { diff --git a/sdk/dotnet/Context.cs b/sdk/dotnet/Context.cs index 05e2c7d..f8b8a20 100644 --- a/sdk/dotnet/Context.cs +++ b/sdk/dotnet/Context.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/ContextAttachment.cs b/sdk/dotnet/ContextAttachment.cs index d24c347..2dbc145 100644 --- a/sdk/dotnet/ContextAttachment.cs +++ b/sdk/dotnet/ContextAttachment.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/DriftDetection.cs b/sdk/dotnet/DriftDetection.cs index 98ae7cc..423e291 100644 --- a/sdk/dotnet/DriftDetection.cs +++ b/sdk/dotnet/DriftDetection.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -54,6 +55,12 @@ namespace Pulumi.Spacelift [SpaceliftResourceType("spacelift:index/driftDetection:DriftDetection")] public partial class DriftDetection : global::Pulumi.CustomResource { + /// + /// Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + /// + [Output("ignoreState")] + public Output IgnoreState { get; private set; } = null!; + /// /// Whether a tracked run should be triggered when drift is detected. /// @@ -125,6 +132,12 @@ public static DriftDetection Get(string name, Input id, DriftDetectionSt public sealed class DriftDetectionArgs : global::Pulumi.ResourceArgs { + /// + /// Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + /// + [Input("ignoreState")] + public Input? IgnoreState { get; set; } + /// /// Whether a tracked run should be triggered when drift is detected. /// @@ -163,6 +176,12 @@ public DriftDetectionArgs() public sealed class DriftDetectionState : global::Pulumi.ResourceArgs { + /// + /// Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + /// + [Input("ignoreState")] + public Input? IgnoreState { get; set; } + /// /// Whether a tracked run should be triggered when drift is detected. /// diff --git a/sdk/dotnet/EnvironmentVariable.cs b/sdk/dotnet/EnvironmentVariable.cs index 72afe70..17ff7a4 100644 --- a/sdk/dotnet/EnvironmentVariable.cs +++ b/sdk/dotnet/EnvironmentVariable.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -96,13 +97,13 @@ public partial class EnvironmentVariable : global::Pulumi.CustomResource public Output StackId { get; private set; } = null!; /// - /// Value of the environment variable + /// Value of the environment variable. Defaults to an empty string. /// [Output("value")] - public Output Value { get; private set; } = null!; + public Output Value { get; private set; } = null!; /// - /// Indicates whether the value can be read back outside a Run. Defaults to `true`. + /// Indicates whether the value is secret or not. Defaults to `true`. /// [Output("writeOnly")] public Output WriteOnly { get; private set; } = null!; @@ -115,7 +116,7 @@ public partial class EnvironmentVariable : global::Pulumi.CustomResource /// The unique name of the resource /// The arguments used to populate this resource's properties /// A bag of options that control this resource's behavior - public EnvironmentVariable(string name, EnvironmentVariableArgs args, CustomResourceOptions? options = null) + public EnvironmentVariable(string name, EnvironmentVariableArgs? args = null, CustomResourceOptions? options = null) : base("spacelift:index/environmentVariable:EnvironmentVariable", name, args ?? new EnvironmentVariableArgs(), MakeResourceOptions(options, "")) { } @@ -131,6 +132,10 @@ private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? { Version = Utilities.Version, PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + AdditionalSecretOutputs = + { + "value", + }, }; var merged = CustomResourceOptions.Merge(defaultOptions, options); // Override the ID if one was specified for consistency with other language SDKs. @@ -178,14 +183,24 @@ public sealed class EnvironmentVariableArgs : global::Pulumi.ResourceArgs [Input("stackId")] public Input? StackId { get; set; } + [Input("value")] + private Input? _value; + /// - /// Value of the environment variable + /// Value of the environment variable. Defaults to an empty string. /// - [Input("value", required: true)] - public Input Value { get; set; } = null!; + public Input? Value + { + get => _value; + set + { + var emptySecret = Output.CreateSecret(0); + _value = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// - /// Indicates whether the value can be read back outside a Run. Defaults to `true`. + /// Indicates whether the value is secret or not. Defaults to `true`. /// [Input("writeOnly")] public Input? WriteOnly { get; set; } @@ -228,14 +243,24 @@ public sealed class EnvironmentVariableState : global::Pulumi.ResourceArgs [Input("stackId")] public Input? StackId { get; set; } + [Input("value")] + private Input? _value; + /// - /// Value of the environment variable + /// Value of the environment variable. Defaults to an empty string. /// - [Input("value")] - public Input? Value { get; set; } + public Input? Value + { + get => _value; + set + { + var emptySecret = Output.CreateSecret(0); + _value = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// - /// Indicates whether the value can be read back outside a Run. Defaults to `true`. + /// Indicates whether the value is secret or not. Defaults to `true`. /// [Input("writeOnly")] public Input? WriteOnly { get; set; } diff --git a/sdk/dotnet/GcpServiceAccount.cs b/sdk/dotnet/GcpServiceAccount.cs index 421e236..181fdfe 100644 --- a/sdk/dotnet/GcpServiceAccount.cs +++ b/sdk/dotnet/GcpServiceAccount.cs @@ -14,8 +14,9 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; - /// using Gcp = Pulumi.Gcp; + /// using Google = Pulumi.Google; /// using Spacelift = Pulumi.Spacelift; /// /// return await Deployment.RunAsync(() => @@ -37,17 +38,18 @@ namespace Pulumi.Spacelift /// }, /// }); /// - /// var k8s_coreProject = new Gcp.Organizations.Project("k8s-coreProject", new() + /// var k8s_coregoogle_project = new Google.Index.Google_project("k8s-coregoogle_project", new() /// { + /// Name = "Kubernetes code", /// ProjectId = "unicorn-k8s-core", /// OrgId = @var.Gcp_organization_id, /// }); /// - /// var k8s_coreIAMMember = new Gcp.Projects.IAMMember("k8s-coreIAMMember", new() + /// var k8s_coregoogle_project_iam_member = new Google.Index.Google_project_iam_member("k8s-coregoogle_project_iam_member", new() /// { - /// Project = k8s_coreProject.Id, + /// Project = k8s_coregoogle_project.Id, /// Role = "roles/owner", - /// Member = k8s_coreGcpServiceAccount.ServiceAccountEmail.Apply(serviceAccountEmail => $"serviceAccount:{serviceAccountEmail}"), + /// Member = $"serviceAccount:{k8s_coreGcpServiceAccount.ServiceAccountEmail}", /// }); /// /// }); diff --git a/sdk/dotnet/GetAccount.cs b/sdk/dotnet/GetAccount.cs index 427128b..2be4fa7 100644 --- a/sdk/dotnet/GetAccount.cs +++ b/sdk/dotnet/GetAccount.cs @@ -20,6 +20,7 @@ public static class GetAccount /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetAccount /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getAccount:getAccount", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getAccount` represents the currently used Spacelift **account** + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var @this = Spacelift.GetAccount.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getAccount:getAccount", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/GetAwsIntegration.cs b/sdk/dotnet/GetAwsIntegration.cs index d0cbdd3..d75d8cd 100644 --- a/sdk/dotnet/GetAwsIntegration.cs +++ b/sdk/dotnet/GetAwsIntegration.cs @@ -14,7 +14,7 @@ public static class GetAwsIntegration /// /// `spacelift.AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. /// - /// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + /// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. /// /// {{% examples %}} /// ## Example Usage @@ -22,6 +22,7 @@ public static class GetAwsIntegration /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -43,7 +44,7 @@ public static Task InvokeAsync(GetAwsIntegrationArgs? a /// /// `spacelift.AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. /// - /// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + /// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. /// /// {{% examples %}} /// ## Example Usage @@ -51,6 +52,7 @@ public static Task InvokeAsync(GetAwsIntegrationArgs? a /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetAwsIntegrationAttachmentExternalId.cs b/sdk/dotnet/GetAwsIntegrationAttachmentExternalId.cs index 21d82d8..3ee20e2 100644 --- a/sdk/dotnet/GetAwsIntegrationAttachmentExternalId.cs +++ b/sdk/dotnet/GetAwsIntegrationAttachmentExternalId.cs @@ -20,6 +20,7 @@ public static class GetAwsIntegrationAttachmentExternalId /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -58,6 +59,7 @@ public static Task InvokeAsync(GetA /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetAwsIntegrations.cs b/sdk/dotnet/GetAwsIntegrations.cs new file mode 100644 index 0000000..beb7f01 --- /dev/null +++ b/sdk/dotnet/GetAwsIntegrations.cs @@ -0,0 +1,47 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetAwsIntegrations + { + /// + /// `spacelift.getAwsIntegrations` represents a list of all the AWS integrations in the Spacelift account visible to the API user. + /// + public static Task InvokeAsync(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getAwsIntegrations:getAwsIntegrations", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getAwsIntegrations` represents a list of all the AWS integrations in the Spacelift account visible to the API user. + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getAwsIntegrations:getAwsIntegrations", InvokeArgs.Empty, options.WithDefaults()); + } + + + [OutputType] + public sealed class GetAwsIntegrationsResult + { + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + public readonly ImmutableArray Integrations; + + [OutputConstructor] + private GetAwsIntegrationsResult( + string id, + + ImmutableArray integrations) + { + Id = id; + Integrations = integrations; + } + } +} diff --git a/sdk/dotnet/GetAwsRole.cs b/sdk/dotnet/GetAwsRole.cs index 4c07bd8..bd4e9dc 100644 --- a/sdk/dotnet/GetAwsRole.cs +++ b/sdk/dotnet/GetAwsRole.cs @@ -24,6 +24,7 @@ public static class GetAwsRole /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -60,6 +61,7 @@ public static Task InvokeAsync(GetAwsRoleArgs? args = null, In /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetAzureDevopsIntegration.cs b/sdk/dotnet/GetAzureDevopsIntegration.cs index 2ca0a86..2c0f4b8 100644 --- a/sdk/dotnet/GetAzureDevopsIntegration.cs +++ b/sdk/dotnet/GetAzureDevopsIntegration.cs @@ -20,6 +20,7 @@ public static class GetAzureDevopsIntegration /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetAzureDevopsIntegration /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getAzureDevopsIntegration:getAzureDevopsIntegration", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getAzureDevopsIntegration` returns details about Azure DevOps integration + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var azureDevopsIntegration = Spacelift.GetAzureDevopsIntegration.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getAzureDevopsIntegration:getAzureDevopsIntegration", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/GetAzureIntegration.cs b/sdk/dotnet/GetAzureIntegration.cs index a33bea9..a2c9580 100644 --- a/sdk/dotnet/GetAzureIntegration.cs +++ b/sdk/dotnet/GetAzureIntegration.cs @@ -20,6 +20,7 @@ public static class GetAzureIntegration /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -47,6 +48,7 @@ public static Task InvokeAsync(GetAzureIntegrationArg /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetAzureIntegrationAttachment.cs b/sdk/dotnet/GetAzureIntegrationAttachment.cs index 224468c..145efe5 100644 --- a/sdk/dotnet/GetAzureIntegrationAttachment.cs +++ b/sdk/dotnet/GetAzureIntegrationAttachment.cs @@ -20,6 +20,7 @@ public static class GetAzureIntegrationAttachment /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -48,6 +49,7 @@ public static Task InvokeAsync(GetAzureInte /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetAzureIntegrations.cs b/sdk/dotnet/GetAzureIntegrations.cs new file mode 100644 index 0000000..6ec0bc6 --- /dev/null +++ b/sdk/dotnet/GetAzureIntegrations.cs @@ -0,0 +1,47 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetAzureIntegrations + { + /// + /// `spacelift.getAzureIntegrations` represents a list of all the Azure integrations in the Spacelift account visible to the API user. + /// + public static Task InvokeAsync(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getAzureIntegrations:getAzureIntegrations", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getAzureIntegrations` represents a list of all the Azure integrations in the Spacelift account visible to the API user. + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getAzureIntegrations:getAzureIntegrations", InvokeArgs.Empty, options.WithDefaults()); + } + + + [OutputType] + public sealed class GetAzureIntegrationsResult + { + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + public readonly ImmutableArray Integrations; + + [OutputConstructor] + private GetAzureIntegrationsResult( + string id, + + ImmutableArray integrations) + { + Id = id; + Integrations = integrations; + } + } +} diff --git a/sdk/dotnet/GetBitbucketCloudIntegration.cs b/sdk/dotnet/GetBitbucketCloudIntegration.cs index 666c5ca..7802a59 100644 --- a/sdk/dotnet/GetBitbucketCloudIntegration.cs +++ b/sdk/dotnet/GetBitbucketCloudIntegration.cs @@ -20,6 +20,7 @@ public static class GetBitbucketCloudIntegration /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetBitbucketCloudIntegration /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getBitbucketCloudIntegration:getBitbucketCloudIntegration", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getBitbucketCloudIntegration` returns details about Bitbucket Cloud integration + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var bitbucketCloudIntegration = Spacelift.GetBitbucketCloudIntegration.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getBitbucketCloudIntegration:getBitbucketCloudIntegration", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/GetBitbucketDatacenterIntegration.cs b/sdk/dotnet/GetBitbucketDatacenterIntegration.cs index e638437..94eaba9 100644 --- a/sdk/dotnet/GetBitbucketDatacenterIntegration.cs +++ b/sdk/dotnet/GetBitbucketDatacenterIntegration.cs @@ -20,6 +20,7 @@ public static class GetBitbucketDatacenterIntegration /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetBitbucketDatacenterIntegration /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getBitbucketDatacenterIntegration:getBitbucketDatacenterIntegration", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getBitbucketDatacenterIntegration` returns details about Bitbucket Datacenter integration + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var bitbucketDatacenterIntegration = Spacelift.GetBitbucketDatacenterIntegration.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getBitbucketDatacenterIntegration:getBitbucketDatacenterIntegration", InvokeArgs.Empty, options.WithDefaults()); } @@ -56,6 +82,10 @@ public sealed class GetBitbucketDatacenterIntegrationResult /// Bitbucket Datacenter integration webhook secret /// public readonly string WebhookSecret; + /// + /// Bitbucket Datacenter integration webhook URL + /// + public readonly string WebhookUrl; [OutputConstructor] private GetBitbucketDatacenterIntegrationResult( @@ -65,12 +95,15 @@ private GetBitbucketDatacenterIntegrationResult( string userFacingHost, - string webhookSecret) + string webhookSecret, + + string webhookUrl) { ApiHost = apiHost; Id = id; UserFacingHost = userFacingHost; WebhookSecret = webhookSecret; + WebhookUrl = webhookUrl; } } } diff --git a/sdk/dotnet/GetContext.cs b/sdk/dotnet/GetContext.cs index b03dbc3..76481fd 100644 --- a/sdk/dotnet/GetContext.cs +++ b/sdk/dotnet/GetContext.cs @@ -20,6 +20,7 @@ public static class GetContext /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -47,6 +48,7 @@ public static Task InvokeAsync(GetContextArgs args, InvokeOpti /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetContextAttachment.cs b/sdk/dotnet/GetContextAttachment.cs index 2bf80b0..6ffbefa 100644 --- a/sdk/dotnet/GetContextAttachment.cs +++ b/sdk/dotnet/GetContextAttachment.cs @@ -20,6 +20,7 @@ public static class GetContextAttachment /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -54,6 +55,7 @@ public static Task InvokeAsync(GetContextAttachmentA /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetContexts.cs b/sdk/dotnet/GetContexts.cs new file mode 100644 index 0000000..6adb7b1 --- /dev/null +++ b/sdk/dotnet/GetContexts.cs @@ -0,0 +1,165 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetContexts + { + /// + /// `spacelift.getContexts` represents all the contexts in the Spacelift account visible to the API user. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var contexts = Spacelift.GetContexts.Invoke(new() + /// { + /// Labels = new[] + /// { + /// new Spacelift.Inputs.GetContextsLabelInputArgs + /// { + /// AnyOfs = new[] + /// { + /// "foo", + /// "bar", + /// }, + /// }, + /// new Spacelift.Inputs.GetContextsLabelInputArgs + /// { + /// AnyOfs = new[] + /// { + /// "baz", + /// }, + /// }, + /// }, + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Task InvokeAsync(GetContextsArgs? args = null, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getContexts:getContexts", args ?? new GetContextsArgs(), options.WithDefaults()); + + /// + /// `spacelift.getContexts` represents all the contexts in the Spacelift account visible to the API user. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var contexts = Spacelift.GetContexts.Invoke(new() + /// { + /// Labels = new[] + /// { + /// new Spacelift.Inputs.GetContextsLabelInputArgs + /// { + /// AnyOfs = new[] + /// { + /// "foo", + /// "bar", + /// }, + /// }, + /// new Spacelift.Inputs.GetContextsLabelInputArgs + /// { + /// AnyOfs = new[] + /// { + /// "baz", + /// }, + /// }, + /// }, + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(GetContextsInvokeArgs? args = null, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getContexts:getContexts", args ?? new GetContextsInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetContextsArgs : global::Pulumi.InvokeArgs + { + [Input("labels")] + private List? _labels; + public List Labels + { + get => _labels ?? (_labels = new List()); + set => _labels = value; + } + + public GetContextsArgs() + { + } + public static new GetContextsArgs Empty => new GetContextsArgs(); + } + + public sealed class GetContextsInvokeArgs : global::Pulumi.InvokeArgs + { + [Input("labels")] + private InputList? _labels; + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + + public GetContextsInvokeArgs() + { + } + public static new GetContextsInvokeArgs Empty => new GetContextsInvokeArgs(); + } + + + [OutputType] + public sealed class GetContextsResult + { + public readonly ImmutableArray Contexts; + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + /// + /// Require contexts to have one of the labels + /// + public readonly ImmutableArray Labels; + + [OutputConstructor] + private GetContextsResult( + ImmutableArray contexts, + + string id, + + ImmutableArray labels) + { + Contexts = contexts; + Id = id; + Labels = labels; + } + } +} diff --git a/sdk/dotnet/GetCurrentSpace.cs b/sdk/dotnet/GetCurrentSpace.cs new file mode 100644 index 0000000..3e71aee --- /dev/null +++ b/sdk/dotnet/GetCurrentSpace.cs @@ -0,0 +1,92 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetCurrentSpace + { + /// + /// `spacelift.getCurrentSpace` is a data source that provides information about the space that an administrative stack is in if the run is executed within Spacelift by a stack or module. This makes it easier to create resources within the same space. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var @this = Spacelift.GetCurrentSpace.Invoke(); + /// + /// var prod_k8s_ie = new Spacelift.Context("prod-k8s-ie", new() + /// { + /// Description = "Configuration details for the compute cluster in 🇮🇪", + /// SpaceId = @this.Apply(@this => @this.Apply(getCurrentSpaceResult => getCurrentSpaceResult.Id)), + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Task InvokeAsync(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getCurrentSpace:getCurrentSpace", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getCurrentSpace` is a data source that provides information about the space that an administrative stack is in if the run is executed within Spacelift by a stack or module. This makes it easier to create resources within the same space. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var @this = Spacelift.GetCurrentSpace.Invoke(); + /// + /// var prod_k8s_ie = new Spacelift.Context("prod-k8s-ie", new() + /// { + /// Description = "Configuration details for the compute cluster in 🇮🇪", + /// SpaceId = @this.Apply(@this => @this.Apply(getCurrentSpaceResult => getCurrentSpaceResult.Id)), + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getCurrentSpace:getCurrentSpace", InvokeArgs.Empty, options.WithDefaults()); + } + + + [OutputType] + public sealed class GetCurrentSpaceResult + { + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + + [OutputConstructor] + private GetCurrentSpaceResult(string id) + { + Id = id; + } + } +} diff --git a/sdk/dotnet/GetCurrentStack.cs b/sdk/dotnet/GetCurrentStack.cs index 6955778..9809925 100644 --- a/sdk/dotnet/GetCurrentStack.cs +++ b/sdk/dotnet/GetCurrentStack.cs @@ -20,6 +20,7 @@ public static class GetCurrentStack /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -29,7 +30,7 @@ public static class GetCurrentStack /// /// var core_kubeconfig = new Spacelift.EnvironmentVariable("core-kubeconfig", new() /// { - /// StackId = @this.Apply(getCurrentStackResult => getCurrentStackResult).Apply(@this => @this.Apply(getCurrentStackResult => getCurrentStackResult.Id)), + /// StackId = @this.Apply(@this => @this.Apply(getCurrentStackResult => getCurrentStackResult.Id)), /// Value = "bacon", /// }); /// @@ -40,6 +41,37 @@ public static class GetCurrentStack /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getCurrentStack:getCurrentStack", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getCurrentStack` is a data source that provides information about the current administrative stack if the run is executed within Spacelift by a stack or module. This allows clever tricks like attaching contexts or policies to the stack that manages them. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var @this = Spacelift.GetCurrentStack.Invoke(); + /// + /// var core_kubeconfig = new Spacelift.EnvironmentVariable("core-kubeconfig", new() + /// { + /// StackId = @this.Apply(@this => @this.Apply(getCurrentStackResult => getCurrentStackResult.Id)), + /// Value = "bacon", + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getCurrentStack:getCurrentStack", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/GetDriftDetection.cs b/sdk/dotnet/GetDriftDetection.cs index 2a23347..04e36b1 100644 --- a/sdk/dotnet/GetDriftDetection.cs +++ b/sdk/dotnet/GetDriftDetection.cs @@ -20,6 +20,7 @@ public static class GetDriftDetection /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -47,6 +48,7 @@ public static Task InvokeAsync(GetDriftDetectionArgs ar /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -69,6 +71,12 @@ public static Output Invoke(GetDriftDetectionInvokeArgs public sealed class GetDriftDetectionArgs : global::Pulumi.InvokeArgs { + /// + /// Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + /// + [Input("ignoreState")] + public bool? IgnoreState { get; set; } + /// /// ID of the stack for which to set up drift detection /// @@ -83,6 +91,12 @@ public GetDriftDetectionArgs() public sealed class GetDriftDetectionInvokeArgs : global::Pulumi.InvokeArgs { + /// + /// Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + /// + [Input("ignoreState")] + public Input? IgnoreState { get; set; } + /// /// ID of the stack for which to set up drift detection /// @@ -104,6 +118,10 @@ public sealed class GetDriftDetectionResult /// public readonly string Id; /// + /// Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + /// + public readonly bool? IgnoreState; + /// /// Whether a tracked run should be triggered when drift is detected. /// public readonly bool Reconcile; @@ -124,6 +142,8 @@ public sealed class GetDriftDetectionResult private GetDriftDetectionResult( string id, + bool? ignoreState, + bool reconcile, ImmutableArray schedules, @@ -133,6 +153,7 @@ private GetDriftDetectionResult( string timezone) { Id = id; + IgnoreState = ignoreState; Reconcile = reconcile; Schedules = schedules; StackId = stackId; diff --git a/sdk/dotnet/GetEnvironmentVariable.cs b/sdk/dotnet/GetEnvironmentVariable.cs index fc42c0d..fde4a89 100644 --- a/sdk/dotnet/GetEnvironmentVariable.cs +++ b/sdk/dotnet/GetEnvironmentVariable.cs @@ -20,6 +20,7 @@ public static class GetEnvironmentVariable /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -60,6 +61,7 @@ public static Task InvokeAsync(GetEnvironmentVaria /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetGcpServiceAccount.cs b/sdk/dotnet/GetGcpServiceAccount.cs index aeee93f..53d29e2 100644 --- a/sdk/dotnet/GetGcpServiceAccount.cs +++ b/sdk/dotnet/GetGcpServiceAccount.cs @@ -18,6 +18,7 @@ public static class GetGcpServiceAccount /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -48,6 +49,7 @@ public static Task InvokeAsync(GetGcpServiceAccountA /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetGithubEnterpriseIntegration.cs b/sdk/dotnet/GetGithubEnterpriseIntegration.cs index 9536424..3634cb5 100644 --- a/sdk/dotnet/GetGithubEnterpriseIntegration.cs +++ b/sdk/dotnet/GetGithubEnterpriseIntegration.cs @@ -20,6 +20,7 @@ public static class GetGithubEnterpriseIntegration /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetGithubEnterpriseIntegration /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getGithubEnterpriseIntegration:getGithubEnterpriseIntegration", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getGithubEnterpriseIntegration` returns details about Github Enterprise integration + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var githubEnterpriseIntegration = Spacelift.GetGithubEnterpriseIntegration.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getGithubEnterpriseIntegration:getGithubEnterpriseIntegration", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/GetGitlabIntegration.cs b/sdk/dotnet/GetGitlabIntegration.cs index 2a0cd21..f112e3f 100644 --- a/sdk/dotnet/GetGitlabIntegration.cs +++ b/sdk/dotnet/GetGitlabIntegration.cs @@ -20,6 +20,7 @@ public static class GetGitlabIntegration /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetGitlabIntegration /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getGitlabIntegration:getGitlabIntegration", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getGitlabIntegration` returns details about Gitlab integration + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var gitlabIntegration = Spacelift.GetGitlabIntegration.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getGitlabIntegration:getGitlabIntegration", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/GetGitlabWebhookEndpoint.cs b/sdk/dotnet/GetGitlabWebhookEndpoint.cs new file mode 100644 index 0000000..59bd91e --- /dev/null +++ b/sdk/dotnet/GetGitlabWebhookEndpoint.cs @@ -0,0 +1,88 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetGitlabWebhookEndpoint + { + /// + /// `spacelift.getGitlabWebhookEndpoint` returns details about Gitlab webhook endpoint + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var @this = Spacelift.GetGitlabWebhookEndpoint.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Task InvokeAsync(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getGitlabWebhookEndpoint:getGitlabWebhookEndpoint", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getGitlabWebhookEndpoint` returns details about Gitlab webhook endpoint + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var @this = Spacelift.GetGitlabWebhookEndpoint.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getGitlabWebhookEndpoint:getGitlabWebhookEndpoint", InvokeArgs.Empty, options.WithDefaults()); + } + + + [OutputType] + public sealed class GetGitlabWebhookEndpointResult + { + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + /// + /// Gitlab webhook endpoint address + /// + public readonly string WebhookEndpoint; + + [OutputConstructor] + private GetGitlabWebhookEndpointResult( + string id, + + string webhookEndpoint) + { + Id = id; + WebhookEndpoint = webhookEndpoint; + } + } +} diff --git a/sdk/dotnet/GetIPs.cs b/sdk/dotnet/GetIPs.cs index d5114f4..9599af3 100644 --- a/sdk/dotnet/GetIPs.cs +++ b/sdk/dotnet/GetIPs.cs @@ -12,7 +12,7 @@ namespace Pulumi.Spacelift public static class GetIPs { /// - /// `spacelift.getIPs` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". + /// `spacelift.getIPs` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". **NOTE:** this does not include the IP addresses of the workers in Spacelift's public worker pool. If you need to ensure that requests made during runs originate from a known set of IP addresses, please consider setting up a [private worker pool](https://docs.spacelift.io/concepts/worker-pools). /// /// {{% examples %}} /// ## Example Usage @@ -20,6 +20,7 @@ public static class GetIPs /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetIPs /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getIPs:getIPs", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getIPs` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". **NOTE:** this does not include the IP addresses of the workers in Spacelift's public worker pool. If you need to ensure that requests made during runs originate from a known set of IP addresses, please consider setting up a [private worker pool](https://docs.spacelift.io/concepts/worker-pools). + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var ips = Spacelift.GetIPs.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getIPs:getIPs", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/GetModule.cs b/sdk/dotnet/GetModule.cs index bd3a4bd..1bfd9b0 100644 --- a/sdk/dotnet/GetModule.cs +++ b/sdk/dotnet/GetModule.cs @@ -18,6 +18,7 @@ public static class GetModule /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -43,6 +44,7 @@ public static Task InvokeAsync(GetModuleArgs args, InvokeOption /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -124,6 +126,10 @@ public sealed class GetModuleResult /// public readonly string Description; /// + /// Indicates whether local preview versions can be triggered on this Module. + /// + public readonly bool EnableLocalPreview; + /// /// GitHub Enterprise (self-hosted) VCS settings /// public readonly ImmutableArray GithubEnterprises; @@ -166,6 +172,10 @@ public sealed class GetModuleResult /// ID of the worker pool to use /// public readonly string WorkerPoolId; + /// + /// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. + /// + public readonly string WorkflowTool; [OutputConstructor] private GetModuleResult( @@ -183,6 +193,8 @@ private GetModuleResult( string description, + bool enableLocalPreview, + ImmutableArray githubEnterprises, ImmutableArray gitlabs, @@ -207,7 +219,9 @@ private GetModuleResult( string terraformProvider, - string workerPoolId) + string workerPoolId, + + string workflowTool) { Administrative = administrative; AwsAssumeRolePolicyStatement = awsAssumeRolePolicyStatement; @@ -216,6 +230,7 @@ private GetModuleResult( BitbucketDatacenters = bitbucketDatacenters; Branch = branch; Description = description; + EnableLocalPreview = enableLocalPreview; GithubEnterprises = githubEnterprises; Gitlabs = gitlabs; Id = id; @@ -229,6 +244,7 @@ private GetModuleResult( SpaceId = spaceId; TerraformProvider = terraformProvider; WorkerPoolId = workerPoolId; + WorkflowTool = workflowTool; } } } diff --git a/sdk/dotnet/GetMountedfile.cs b/sdk/dotnet/GetMountedfile.cs index 8c8b480..e746ef1 100644 --- a/sdk/dotnet/GetMountedfile.cs +++ b/sdk/dotnet/GetMountedfile.cs @@ -20,6 +20,7 @@ public static class GetMountedfile /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -60,6 +61,7 @@ public static Task InvokeAsync(GetMountedfileArgs args, In /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetNamedWebhook.cs b/sdk/dotnet/GetNamedWebhook.cs new file mode 100644 index 0000000..f7aaa9f --- /dev/null +++ b/sdk/dotnet/GetNamedWebhook.cs @@ -0,0 +1,128 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetNamedWebhook + { + /// + /// `spacelift.NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + /// + public static Task InvokeAsync(GetNamedWebhookArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getNamedWebhook:getNamedWebhook", args ?? new GetNamedWebhookArgs(), options.WithDefaults()); + + /// + /// `spacelift.NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + /// + public static Output Invoke(GetNamedWebhookInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getNamedWebhook:getNamedWebhook", args ?? new GetNamedWebhookInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetNamedWebhookArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the webhook + /// + [Input("webhookId", required: true)] + public string WebhookId { get; set; } = null!; + + public GetNamedWebhookArgs() + { + } + public static new GetNamedWebhookArgs Empty => new GetNamedWebhookArgs(); + } + + public sealed class GetNamedWebhookInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the webhook + /// + [Input("webhookId", required: true)] + public Input WebhookId { get; set; } = null!; + + public GetNamedWebhookInvokeArgs() + { + } + public static new GetNamedWebhookInvokeArgs Empty => new GetNamedWebhookInvokeArgs(); + } + + + [OutputType] + public sealed class GetNamedWebhookResult + { + /// + /// enables or disables sending webhooks. + /// + public readonly bool Enabled; + /// + /// endpoint to send the requests to + /// + public readonly string Endpoint; + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + /// + /// labels for the webhook to use when referring in policies or filtering them + /// + public readonly ImmutableArray Labels; + /// + /// the name for the webhook which will also be used to generate the id + /// + public readonly string Name; + /// + /// secret used to sign each request so you're able to verify that the request comes from us. + /// + public readonly string Secret; + /// + /// secret header keys which are currently set for this webhook + /// + public readonly ImmutableArray SecretHeaderKeys; + /// + /// ID of the space the webhook is in + /// + public readonly string SpaceId; + /// + /// ID of the webhook + /// + public readonly string WebhookId; + + [OutputConstructor] + private GetNamedWebhookResult( + bool enabled, + + string endpoint, + + string id, + + ImmutableArray labels, + + string name, + + string secret, + + ImmutableArray secretHeaderKeys, + + string spaceId, + + string webhookId) + { + Enabled = enabled; + Endpoint = endpoint; + Id = id; + Labels = labels; + Name = name; + Secret = secret; + SecretHeaderKeys = secretHeaderKeys; + SpaceId = spaceId; + WebhookId = webhookId; + } + } +} diff --git a/sdk/dotnet/GetPolicies.cs b/sdk/dotnet/GetPolicies.cs index 2828829..09be478 100644 --- a/sdk/dotnet/GetPolicies.cs +++ b/sdk/dotnet/GetPolicies.cs @@ -93,19 +93,12 @@ public sealed class GetPoliciesArgs : global::Pulumi.InvokeArgs { [Input("labels")] private List? _labels; - - /// - /// required labels to match - /// public List Labels { get => _labels ?? (_labels = new List()); set => _labels = value; } - /// - /// required policy type - /// [Input("type")] public string? Type { get; set; } @@ -119,19 +112,12 @@ public sealed class GetPoliciesInvokeArgs : global::Pulumi.InvokeArgs { [Input("labels")] private InputList? _labels; - - /// - /// required labels to match - /// public InputList Labels { get => _labels ?? (_labels = new InputList()); set => _labels = value; } - /// - /// required policy type - /// [Input("type")] public Input? Type { get; set; } diff --git a/sdk/dotnet/GetPolicy.cs b/sdk/dotnet/GetPolicy.cs index f432b04..1965531 100644 --- a/sdk/dotnet/GetPolicy.cs +++ b/sdk/dotnet/GetPolicy.cs @@ -20,6 +20,7 @@ public static class GetPolicy /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -51,6 +52,7 @@ public static Task InvokeAsync(GetPolicyArgs args, InvokeOption /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetScheduledDeleteStack.cs b/sdk/dotnet/GetScheduledDeleteStack.cs new file mode 100644 index 0000000..70278ae --- /dev/null +++ b/sdk/dotnet/GetScheduledDeleteStack.cs @@ -0,0 +1,151 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetScheduledDeleteStack + { + /// + /// `spacelift.ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var ireland_kubeconfig_delete = Spacelift.GetScheduledDeleteStack.Invoke(new() + /// { + /// ScheduledDeleteStackId = "$STACK_ID/$SCHEDULED_DELETE_STACK_ID", + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Task InvokeAsync(GetScheduledDeleteStackArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getScheduledDeleteStack:getScheduledDeleteStack", args ?? new GetScheduledDeleteStackArgs(), options.WithDefaults()); + + /// + /// `spacelift.ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var ireland_kubeconfig_delete = Spacelift.GetScheduledDeleteStack.Invoke(new() + /// { + /// ScheduledDeleteStackId = "$STACK_ID/$SCHEDULED_DELETE_STACK_ID", + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(GetScheduledDeleteStackInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getScheduledDeleteStack:getScheduledDeleteStack", args ?? new GetScheduledDeleteStackInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetScheduledDeleteStackArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the scheduled delete*stack (stack*id/schedule_id) + /// + [Input("scheduledDeleteStackId", required: true)] + public string ScheduledDeleteStackId { get; set; } = null!; + + public GetScheduledDeleteStackArgs() + { + } + public static new GetScheduledDeleteStackArgs Empty => new GetScheduledDeleteStackArgs(); + } + + public sealed class GetScheduledDeleteStackInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the scheduled delete*stack (stack*id/schedule_id) + /// + [Input("scheduledDeleteStackId", required: true)] + public Input ScheduledDeleteStackId { get; set; } = null!; + + public GetScheduledDeleteStackInvokeArgs() + { + } + public static new GetScheduledDeleteStackInvokeArgs Empty => new GetScheduledDeleteStackInvokeArgs(); + } + + + [OutputType] + public sealed class GetScheduledDeleteStackResult + { + /// + /// Timestamp (unix timestamp) at which time the scheduling should happen. + /// + public readonly int At; + /// + /// Indicates whether the resources of the stack should be deleted. + /// + public readonly bool DeleteResources; + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + /// + /// ID of the schedule + /// + public readonly string ScheduleId; + /// + /// ID of the scheduled delete*stack (stack*id/schedule_id) + /// + public readonly string ScheduledDeleteStackId; + /// + /// Stack ID of the scheduling config + /// + public readonly string StackId; + + [OutputConstructor] + private GetScheduledDeleteStackResult( + int at, + + bool deleteResources, + + string id, + + string scheduleId, + + string scheduledDeleteStackId, + + string stackId) + { + At = at; + DeleteResources = deleteResources; + Id = id; + ScheduleId = scheduleId; + ScheduledDeleteStackId = scheduledDeleteStackId; + StackId = stackId; + } + } +} diff --git a/sdk/dotnet/GetScheduledTask.cs b/sdk/dotnet/GetScheduledTask.cs new file mode 100644 index 0000000..f4e3405 --- /dev/null +++ b/sdk/dotnet/GetScheduledTask.cs @@ -0,0 +1,165 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetScheduledTask + { + /// + /// `spacelift.ScheduledTask` represents a scheduling configuration for a Stack. It will trigger a task on the given timestamp/schedule. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var ireland_kubeconfig_destroy = Spacelift.GetScheduledTask.Invoke(new() + /// { + /// ScheduledTaskId = "$STACK_ID/$SCHEDULED_TASK_ID", + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Task InvokeAsync(GetScheduledTaskArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getScheduledTask:getScheduledTask", args ?? new GetScheduledTaskArgs(), options.WithDefaults()); + + /// + /// `spacelift.ScheduledTask` represents a scheduling configuration for a Stack. It will trigger a task on the given timestamp/schedule. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var ireland_kubeconfig_destroy = Spacelift.GetScheduledTask.Invoke(new() + /// { + /// ScheduledTaskId = "$STACK_ID/$SCHEDULED_TASK_ID", + /// }); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(GetScheduledTaskInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getScheduledTask:getScheduledTask", args ?? new GetScheduledTaskInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetScheduledTaskArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the scheduled task (stack*id/schedule*id) + /// + [Input("scheduledTaskId", required: true)] + public string ScheduledTaskId { get; set; } = null!; + + public GetScheduledTaskArgs() + { + } + public static new GetScheduledTaskArgs Empty => new GetScheduledTaskArgs(); + } + + public sealed class GetScheduledTaskInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the scheduled task (stack*id/schedule*id) + /// + [Input("scheduledTaskId", required: true)] + public Input ScheduledTaskId { get; set; } = null!; + + public GetScheduledTaskInvokeArgs() + { + } + public static new GetScheduledTaskInvokeArgs Empty => new GetScheduledTaskInvokeArgs(); + } + + + [OutputType] + public sealed class GetScheduledTaskResult + { + /// + /// Timestamp (unix timestamp) at which time the scheduling should happen. + /// + public readonly int At; + /// + /// Command that will be run. + /// + public readonly string Command; + /// + /// List of cron schedule expressions based on which the scheduled task should be triggered. + /// + public readonly ImmutableArray Everies; + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + /// + /// ID of the schedule + /// + public readonly string ScheduleId; + /// + /// ID of the scheduled task (stack*id/schedule*id) + /// + public readonly string ScheduledTaskId; + /// + /// Stack ID of the scheduled task + /// + public readonly string StackId; + /// + /// Timezone in which the schedule is expressed. Defaults to `UTC`. + /// + public readonly string Timezone; + + [OutputConstructor] + private GetScheduledTaskResult( + int at, + + string command, + + ImmutableArray everies, + + string id, + + string scheduleId, + + string scheduledTaskId, + + string stackId, + + string timezone) + { + At = at; + Command = command; + Everies = everies; + Id = id; + ScheduleId = scheduleId; + ScheduledTaskId = scheduledTaskId; + StackId = stackId; + Timezone = timezone; + } + } +} diff --git a/sdk/dotnet/GetSpace.cs b/sdk/dotnet/GetSpace.cs index 5f8557c..b732f99 100644 --- a/sdk/dotnet/GetSpace.cs +++ b/sdk/dotnet/GetSpace.cs @@ -20,6 +20,7 @@ public static class GetSpace /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -51,6 +52,7 @@ public static Task InvokeAsync(GetSpaceArgs args, InvokeOptions? /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -120,6 +122,10 @@ public sealed class GetSpaceResult /// public readonly bool InheritEntities; /// + /// list of labels describing a space + /// + public readonly ImmutableArray Labels; + /// /// name of the space /// public readonly string Name; @@ -140,6 +146,8 @@ private GetSpaceResult( bool inheritEntities, + ImmutableArray labels, + string name, string parentSpaceId, @@ -149,6 +157,7 @@ private GetSpaceResult( Description = description; Id = id; InheritEntities = inheritEntities; + Labels = labels; Name = name; ParentSpaceId = parentSpaceId; SpaceId = spaceId; diff --git a/sdk/dotnet/GetSpaceByPath.cs b/sdk/dotnet/GetSpaceByPath.cs new file mode 100644 index 0000000..60d7d7a --- /dev/null +++ b/sdk/dotnet/GetSpaceByPath.cs @@ -0,0 +1,170 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetSpaceByPath + { + /// + /// `spacelift.getSpaceByPath` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. In contrary to `spacelift.Space`, this resource is identified by a path, not by an ID. For this data source to work, path must be unique. If there are multiple spaces with the same path, this datasource will fail. + /// **Disclaimer:** + /// This datasource can only be used in a stack that resides in a space with inheritance enabled. In addition, the parent spaces (excluding root) must also have inheritance enabled. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var space = Spacelift.GetSpaceByPath.Invoke(new() + /// { + /// SpacePath = "root/second space/my space", + /// }); + /// + /// return new Dictionary<string, object?> + /// { + /// ["spaceDescription"] = space.Apply(getSpaceByPathResult => getSpaceByPathResult.Description), + /// }; + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Task InvokeAsync(GetSpaceByPathArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getSpaceByPath:getSpaceByPath", args ?? new GetSpaceByPathArgs(), options.WithDefaults()); + + /// + /// `spacelift.getSpaceByPath` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. In contrary to `spacelift.Space`, this resource is identified by a path, not by an ID. For this data source to work, path must be unique. If there are multiple spaces with the same path, this datasource will fail. + /// **Disclaimer:** + /// This datasource can only be used in a stack that resides in a space with inheritance enabled. In addition, the parent spaces (excluding root) must also have inheritance enabled. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var space = Spacelift.GetSpaceByPath.Invoke(new() + /// { + /// SpacePath = "root/second space/my space", + /// }); + /// + /// return new Dictionary<string, object?> + /// { + /// ["spaceDescription"] = space.Apply(getSpaceByPathResult => getSpaceByPathResult.Description), + /// }; + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(GetSpaceByPathInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getSpaceByPath:getSpaceByPath", args ?? new GetSpaceByPathInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetSpaceByPathArgs : global::Pulumi.InvokeArgs + { + /// + /// path to the space - a series of space names separated by `/` + /// + [Input("spacePath", required: true)] + public string SpacePath { get; set; } = null!; + + public GetSpaceByPathArgs() + { + } + public static new GetSpaceByPathArgs Empty => new GetSpaceByPathArgs(); + } + + public sealed class GetSpaceByPathInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// path to the space - a series of space names separated by `/` + /// + [Input("spacePath", required: true)] + public Input SpacePath { get; set; } = null!; + + public GetSpaceByPathInvokeArgs() + { + } + public static new GetSpaceByPathInvokeArgs Empty => new GetSpaceByPathInvokeArgs(); + } + + + [OutputType] + public sealed class GetSpaceByPathResult + { + /// + /// free-form space description for users + /// + public readonly string Description; + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + /// + /// indication whether access to this space inherits read access to entities from the parent space + /// + public readonly bool InheritEntities; + /// + /// list of labels describing a space + /// + public readonly ImmutableArray Labels; + /// + /// name of the space + /// + public readonly string Name; + /// + /// immutable ID (slug) of parent space + /// + public readonly string ParentSpaceId; + /// + /// path to the space - a series of space names separated by `/` + /// + public readonly string SpacePath; + + [OutputConstructor] + private GetSpaceByPathResult( + string description, + + string id, + + bool inheritEntities, + + ImmutableArray labels, + + string name, + + string parentSpaceId, + + string spacePath) + { + Description = description; + Id = id; + InheritEntities = inheritEntities; + Labels = labels; + Name = name; + ParentSpaceId = parentSpaceId; + SpacePath = spacePath; + } + } +} diff --git a/sdk/dotnet/GetSpaces.cs b/sdk/dotnet/GetSpaces.cs new file mode 100644 index 0000000..a7d42da --- /dev/null +++ b/sdk/dotnet/GetSpaces.cs @@ -0,0 +1,93 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetSpaces + { + /// + /// `spacelift.getSpaces` can find all spaces in the spacelift organization. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var @this = Spacelift.GetSpaces.Invoke(); + /// + /// return new Dictionary<string, object?> + /// { + /// ["spaces"] = @this.Apply(@this => @this.Apply(getSpacesResult => getSpacesResult.Spaces)), + /// }; + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Task InvokeAsync(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getSpaces:getSpaces", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getSpaces` can find all spaces in the spacelift organization. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var @this = Spacelift.GetSpaces.Invoke(); + /// + /// return new Dictionary<string, object?> + /// { + /// ["spaces"] = @this.Apply(@this => @this.Apply(getSpacesResult => getSpacesResult.Spaces)), + /// }; + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getSpaces:getSpaces", InvokeArgs.Empty, options.WithDefaults()); + } + + + [OutputType] + public sealed class GetSpacesResult + { + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + public readonly ImmutableArray Spaces; + + [OutputConstructor] + private GetSpacesResult( + string id, + + ImmutableArray spaces) + { + Id = id; + Spaces = spaces; + } + } +} diff --git a/sdk/dotnet/GetStack.cs b/sdk/dotnet/GetStack.cs index d26ff15..05501a4 100644 --- a/sdk/dotnet/GetStack.cs +++ b/sdk/dotnet/GetStack.cs @@ -20,6 +20,7 @@ public static class GetStack /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -47,6 +48,7 @@ public static Task InvokeAsync(GetStackArgs args, InvokeOptions? /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -129,6 +131,18 @@ public List AfterPlans set => _afterPlans = value; } + [Input("afterRuns")] + private List? _afterRuns; + + /// + /// List of after-run scripts + /// + public List AfterRuns + { + get => _afterRuns ?? (_afterRuns = new List()); + set => _afterRuns = value; + } + [Input("beforeApplies")] private List? _beforeApplies; @@ -263,6 +277,18 @@ public InputList AfterPlans set => _afterPlans = value; } + [Input("afterRuns")] + private InputList? _afterRuns; + + /// + /// List of after-run scripts + /// + public InputList AfterRuns + { + get => _afterRuns ?? (_afterRuns = new InputList()); + set => _afterRuns = value; + } + [Input("beforeApplies")] private InputList? _beforeApplies; @@ -364,6 +390,10 @@ public sealed class GetStackResult /// public readonly ImmutableArray AfterPlans; /// + /// List of after-run scripts + /// + public readonly ImmutableArray AfterRuns; + /// /// Ansible-specific configuration. Presence means this Stack is an Ansible Stack. /// public readonly ImmutableArray Ansibles; @@ -465,6 +495,10 @@ public sealed class GetStackResult /// public readonly ImmutableArray Pulumis; /// + /// One-way VCS integration using a raw Git repository link + /// + public readonly ImmutableArray RawGits; + /// /// Name of the repository, without the owner part /// public readonly string Repository; @@ -484,8 +518,16 @@ public sealed class GetStackResult /// ID (slug) of the stack /// public readonly string StackId; + /// + /// Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. + /// + public readonly bool TerraformExternalStateAccess; public readonly bool TerraformSmartSanitization; public readonly string TerraformVersion; + /// + /// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. + /// + public readonly string TerraformWorkflowTool; public readonly string TerraformWorkspace; /// /// ID of the worker pool to use @@ -506,6 +548,8 @@ private GetStackResult( ImmutableArray afterPlans, + ImmutableArray afterRuns, + ImmutableArray ansibles, bool autodeploy, @@ -558,6 +602,8 @@ private GetStackResult( ImmutableArray pulumis, + ImmutableArray rawGits, + string repository, string runnerImage, @@ -568,10 +614,14 @@ private GetStackResult( string stackId, + bool terraformExternalStateAccess, + bool terraformSmartSanitization, string terraformVersion, + string terraformWorkflowTool, + string terraformWorkspace, string workerPoolId) @@ -582,6 +632,7 @@ private GetStackResult( AfterInits = afterInits; AfterPerforms = afterPerforms; AfterPlans = afterPlans; + AfterRuns = afterRuns; Ansibles = ansibles; Autodeploy = autodeploy; Autoretry = autoretry; @@ -608,13 +659,16 @@ private GetStackResult( ProjectRoot = projectRoot; ProtectFromDeletion = protectFromDeletion; Pulumis = pulumis; + RawGits = rawGits; Repository = repository; RunnerImage = runnerImage; Showcases = showcases; SpaceId = spaceId; StackId = stackId; + TerraformExternalStateAccess = terraformExternalStateAccess; TerraformSmartSanitization = terraformSmartSanitization; TerraformVersion = terraformVersion; + TerraformWorkflowTool = terraformWorkflowTool; TerraformWorkspace = terraformWorkspace; WorkerPoolId = workerPoolId; } diff --git a/sdk/dotnet/GetStackAwsRole.cs b/sdk/dotnet/GetStackAwsRole.cs index 3a399eb..3e4ce72 100644 --- a/sdk/dotnet/GetStackAwsRole.cs +++ b/sdk/dotnet/GetStackAwsRole.cs @@ -26,6 +26,7 @@ public static class GetStackAwsRole /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -64,6 +65,7 @@ public static Task InvokeAsync(GetStackAwsRoleArgs? args /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetStackGcpServiceAccount.cs b/sdk/dotnet/GetStackGcpServiceAccount.cs index 47af71c..6c711a1 100644 --- a/sdk/dotnet/GetStackGcpServiceAccount.cs +++ b/sdk/dotnet/GetStackGcpServiceAccount.cs @@ -18,6 +18,7 @@ public static class GetStackGcpServiceAccount /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -48,6 +49,7 @@ public static Task InvokeAsync(GetStackGcpServi /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetStacks.cs b/sdk/dotnet/GetStacks.cs new file mode 100644 index 0000000..10e120c --- /dev/null +++ b/sdk/dotnet/GetStacks.cs @@ -0,0 +1,250 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + public static class GetStacks + { + /// + /// `spacelift.getStacks` represents all the stacks in the Spacelift account visible to the API user, matching predicates. + /// + public static Task InvokeAsync(GetStacksArgs? args = null, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getStacks:getStacks", args ?? new GetStacksArgs(), options.WithDefaults()); + + /// + /// `spacelift.getStacks` represents all the stacks in the Spacelift account visible to the API user, matching predicates. + /// + public static Output Invoke(GetStacksInvokeArgs? args = null, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getStacks:getStacks", args ?? new GetStacksInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetStacksArgs : global::Pulumi.InvokeArgs + { + [Input("administrative")] + public Inputs.GetStacksAdministrativeArgs? Administrative { get; set; } + + [Input("branch")] + public Inputs.GetStacksBranchArgs? Branch { get; set; } + + /// + /// Require stacks to be on one of the commits + /// + [Input("commit")] + public Inputs.GetStacksCommitArgs? Commit { get; set; } + + [Input("labels")] + private List? _labels; + public List Labels + { + get => _labels ?? (_labels = new List()); + set => _labels = value; + } + + /// + /// Require stacks to be locked + /// + [Input("locked")] + public Inputs.GetStacksLockedArgs? Locked { get; set; } + + [Input("name")] + public Inputs.GetStacksNameArgs? Name { get; set; } + + [Input("projectRoot")] + public Inputs.GetStacksProjectRootArgs? ProjectRoot { get; set; } + + [Input("repository")] + public Inputs.GetStacksRepositoryArgs? Repository { get; set; } + + /// + /// Require stacks to have one of the states + /// + [Input("state")] + public Inputs.GetStacksStateArgs? State { get; set; } + + /// + /// Require stacks to use one of the IaC vendors + /// + [Input("vendor")] + public Inputs.GetStacksVendorArgs? Vendor { get; set; } + + /// + /// Require stacks to use one of the worker pools + /// + [Input("workerPool")] + public Inputs.GetStacksWorkerPoolArgs? WorkerPool { get; set; } + + public GetStacksArgs() + { + } + public static new GetStacksArgs Empty => new GetStacksArgs(); + } + + public sealed class GetStacksInvokeArgs : global::Pulumi.InvokeArgs + { + [Input("administrative")] + public Input? Administrative { get; set; } + + [Input("branch")] + public Input? Branch { get; set; } + + /// + /// Require stacks to be on one of the commits + /// + [Input("commit")] + public Input? Commit { get; set; } + + [Input("labels")] + private InputList? _labels; + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + + /// + /// Require stacks to be locked + /// + [Input("locked")] + public Input? Locked { get; set; } + + [Input("name")] + public Input? Name { get; set; } + + [Input("projectRoot")] + public Input? ProjectRoot { get; set; } + + [Input("repository")] + public Input? Repository { get; set; } + + /// + /// Require stacks to have one of the states + /// + [Input("state")] + public Input? State { get; set; } + + /// + /// Require stacks to use one of the IaC vendors + /// + [Input("vendor")] + public Input? Vendor { get; set; } + + /// + /// Require stacks to use one of the worker pools + /// + [Input("workerPool")] + public Input? WorkerPool { get; set; } + + public GetStacksInvokeArgs() + { + } + public static new GetStacksInvokeArgs Empty => new GetStacksInvokeArgs(); + } + + + [OutputType] + public sealed class GetStacksResult + { + /// + /// Require stacks to be administrative or not + /// + public readonly Outputs.GetStacksAdministrativeResult? Administrative; + /// + /// Require stacks to be on one of the branches + /// + public readonly Outputs.GetStacksBranchResult? Branch; + /// + /// Require stacks to be on one of the commits + /// + public readonly Outputs.GetStacksCommitResult? Commit; + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + /// + /// Require stacks to have one of the labels + /// + public readonly ImmutableArray Labels; + /// + /// Require stacks to be locked + /// + public readonly Outputs.GetStacksLockedResult? Locked; + /// + /// Require stacks to have one of the names + /// + public readonly Outputs.GetStacksNameResult? Name; + /// + /// Require stacks to be in one of the project roots + /// + public readonly Outputs.GetStacksProjectRootResult? ProjectRoot; + /// + /// Require stacks to be in one of the repositories + /// + public readonly Outputs.GetStacksRepositoryResult? Repository; + /// + /// List of stacks matching the predicates + /// + public readonly ImmutableArray Stacks; + /// + /// Require stacks to have one of the states + /// + public readonly Outputs.GetStacksStateResult? State; + /// + /// Require stacks to use one of the IaC vendors + /// + public readonly Outputs.GetStacksVendorResult? Vendor; + /// + /// Require stacks to use one of the worker pools + /// + public readonly Outputs.GetStacksWorkerPoolResult? WorkerPool; + + [OutputConstructor] + private GetStacksResult( + Outputs.GetStacksAdministrativeResult? administrative, + + Outputs.GetStacksBranchResult? branch, + + Outputs.GetStacksCommitResult? commit, + + string id, + + ImmutableArray labels, + + Outputs.GetStacksLockedResult? locked, + + Outputs.GetStacksNameResult? name, + + Outputs.GetStacksProjectRootResult? projectRoot, + + Outputs.GetStacksRepositoryResult? repository, + + ImmutableArray stacks, + + Outputs.GetStacksStateResult? state, + + Outputs.GetStacksVendorResult? vendor, + + Outputs.GetStacksWorkerPoolResult? workerPool) + { + Administrative = administrative; + Branch = branch; + Commit = commit; + Id = id; + Labels = labels; + Locked = locked; + Name = name; + ProjectRoot = projectRoot; + Repository = repository; + Stacks = stacks; + State = state; + Vendor = vendor; + WorkerPool = workerPool; + } + } +} diff --git a/sdk/dotnet/GetVcsAgentPools.cs b/sdk/dotnet/GetVcsAgentPools.cs index 7b3cd9d..c0d3b87 100644 --- a/sdk/dotnet/GetVcsAgentPools.cs +++ b/sdk/dotnet/GetVcsAgentPools.cs @@ -20,6 +20,7 @@ public static class GetVcsAgentPools /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetVcsAgentPools /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getVcsAgentPools:getVcsAgentPools", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getVcsAgentPools` represents the VCS agent pools assigned to the Spacelift account. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var vcs_agent_pools = Spacelift.GetVcsAgentPools.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getVcsAgentPools:getVcsAgentPools", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/GetWebhook.cs b/sdk/dotnet/GetWebhook.cs index f7ac562..2341fe7 100644 --- a/sdk/dotnet/GetWebhook.cs +++ b/sdk/dotnet/GetWebhook.cs @@ -20,6 +20,7 @@ public static class GetWebhook /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -47,6 +48,7 @@ public static Task InvokeAsync(GetWebhookArgs args, InvokeOpti /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/GetWorkerPool.cs b/sdk/dotnet/GetWorkerPool.cs index b7d657f..3d48657 100644 --- a/sdk/dotnet/GetWorkerPool.cs +++ b/sdk/dotnet/GetWorkerPool.cs @@ -20,6 +20,7 @@ public static class GetWorkerPool /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -27,7 +28,7 @@ public static class GetWorkerPool /// { /// var k8s_core = Spacelift.GetWorkerPool.Invoke(new() /// { - /// WorkerPoolId = "k8s-core", + /// WorkerPoolId = "01G1KTZ4BA86RBN3XNN3YK9EWT", /// }); /// /// }); @@ -47,6 +48,7 @@ public static Task InvokeAsync(GetWorkerPoolArgs args, Invo /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -54,7 +56,7 @@ public static Task InvokeAsync(GetWorkerPoolArgs args, Invo /// { /// var k8s_core = Spacelift.GetWorkerPool.Invoke(new() /// { - /// WorkerPoolId = "k8s-core", + /// WorkerPoolId = "01G1KTZ4BA86RBN3XNN3YK9EWT", /// }); /// /// }); diff --git a/sdk/dotnet/GetWorkerPools.cs b/sdk/dotnet/GetWorkerPools.cs index 6054f5a..0b708ac 100644 --- a/sdk/dotnet/GetWorkerPools.cs +++ b/sdk/dotnet/GetWorkerPools.cs @@ -20,6 +20,7 @@ public static class GetWorkerPools /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,6 +35,31 @@ public static class GetWorkerPools /// public static Task InvokeAsync(InvokeOptions? options = null) => global::Pulumi.Deployment.Instance.InvokeAsync("spacelift:index/getWorkerPools:getWorkerPools", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// `spacelift.getWorkerPools` represents the worker pools assigned to the Spacelift account. + /// + /// {{% examples %}} + /// ## Example Usage + /// {{% example %}} + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var worker_pools = Spacelift.GetWorkerPools.Invoke(); + /// + /// }); + /// ``` + /// {{% /example %}} + /// {{% /examples %}} + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("spacelift:index/getWorkerPools:getWorkerPools", InvokeArgs.Empty, options.WithDefaults()); } diff --git a/sdk/dotnet/IdpGroupMapping.cs b/sdk/dotnet/IdpGroupMapping.cs new file mode 100644 index 0000000..d154332 --- /dev/null +++ b/sdk/dotnet/IdpGroupMapping.cs @@ -0,0 +1,145 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.IdpGroupMapping` represents a mapping (binding) between a user group (as provided by IdP) and a Spacelift User Management Policy. If you assign permissions (a Policy) to a user group, all users in the group will have those permissions unless the user's permissions are higher than the group's permissions. + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var test = new Spacelift.IdpGroupMapping("test", new() + /// { + /// Policies = new[] + /// { + /// new Spacelift.Inputs.IdpGroupMappingPolicyArgs + /// { + /// Role = "ADMIN", + /// SpaceId = "root", + /// }, + /// new Spacelift.Inputs.IdpGroupMappingPolicyArgs + /// { + /// Role = "ADMIN", + /// SpaceId = "legacy", + /// }, + /// }, + /// }); + /// + /// }); + /// ``` + /// + [SpaceliftResourceType("spacelift:index/idpGroupMapping:IdpGroupMapping")] + public partial class IdpGroupMapping : global::Pulumi.CustomResource + { + /// + /// Name of the user group - should be unique in one account + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("policies")] + public Output> Policies { get; private set; } = null!; + + + /// + /// Create a IdpGroupMapping resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public IdpGroupMapping(string name, IdpGroupMappingArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/idpGroupMapping:IdpGroupMapping", name, args ?? new IdpGroupMappingArgs(), MakeResourceOptions(options, "")) + { + } + + private IdpGroupMapping(string name, Input id, IdpGroupMappingState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/idpGroupMapping:IdpGroupMapping", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing IdpGroupMapping resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static IdpGroupMapping Get(string name, Input id, IdpGroupMappingState? state = null, CustomResourceOptions? options = null) + { + return new IdpGroupMapping(name, id, state, options); + } + } + + public sealed class IdpGroupMappingArgs : global::Pulumi.ResourceArgs + { + /// + /// Name of the user group - should be unique in one account + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("policies", required: true)] + private InputList? _policies; + public InputList Policies + { + get => _policies ?? (_policies = new InputList()); + set => _policies = value; + } + + public IdpGroupMappingArgs() + { + } + public static new IdpGroupMappingArgs Empty => new IdpGroupMappingArgs(); + } + + public sealed class IdpGroupMappingState : global::Pulumi.ResourceArgs + { + /// + /// Name of the user group - should be unique in one account + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("policies")] + private InputList? _policies; + public InputList Policies + { + get => _policies ?? (_policies = new InputList()); + set => _policies = value; + } + + public IdpGroupMappingState() + { + } + public static new IdpGroupMappingState Empty => new IdpGroupMappingState(); + } +} diff --git a/sdk/dotnet/Inputs/GetContextsLabel.cs b/sdk/dotnet/Inputs/GetContextsLabel.cs new file mode 100644 index 0000000..de046f7 --- /dev/null +++ b/sdk/dotnet/Inputs/GetContextsLabel.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetContextsLabelArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetContextsLabelArgs() + { + } + public static new GetContextsLabelArgs Empty => new GetContextsLabelArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetContextsLabelArgs.cs b/sdk/dotnet/Inputs/GetContextsLabelArgs.cs new file mode 100644 index 0000000..652d255 --- /dev/null +++ b/sdk/dotnet/Inputs/GetContextsLabelArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetContextsLabelInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetContextsLabelInputArgs() + { + } + public static new GetContextsLabelInputArgs Empty => new GetContextsLabelInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksAdministrative.cs b/sdk/dotnet/Inputs/GetStacksAdministrative.cs new file mode 100644 index 0000000..87c2f72 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksAdministrative.cs @@ -0,0 +1,23 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksAdministrativeArgs : global::Pulumi.InvokeArgs + { + [Input("equals")] + public bool? Equals { get; set; } + + public GetStacksAdministrativeArgs() + { + } + public static new GetStacksAdministrativeArgs Empty => new GetStacksAdministrativeArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksAdministrativeArgs.cs b/sdk/dotnet/Inputs/GetStacksAdministrativeArgs.cs new file mode 100644 index 0000000..e202584 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksAdministrativeArgs.cs @@ -0,0 +1,23 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksAdministrativeInputArgs : global::Pulumi.ResourceArgs + { + [Input("equals")] + public Input? Equals { get; set; } + + public GetStacksAdministrativeInputArgs() + { + } + public static new GetStacksAdministrativeInputArgs Empty => new GetStacksAdministrativeInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksBranch.cs b/sdk/dotnet/Inputs/GetStacksBranch.cs new file mode 100644 index 0000000..2139859 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksBranch.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksBranchArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksBranchArgs() + { + } + public static new GetStacksBranchArgs Empty => new GetStacksBranchArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksBranchArgs.cs b/sdk/dotnet/Inputs/GetStacksBranchArgs.cs new file mode 100644 index 0000000..27813d8 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksBranchArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksBranchInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksBranchInputArgs() + { + } + public static new GetStacksBranchInputArgs Empty => new GetStacksBranchInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksCommit.cs b/sdk/dotnet/Inputs/GetStacksCommit.cs new file mode 100644 index 0000000..9a76cfb --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksCommit.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksCommitArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksCommitArgs() + { + } + public static new GetStacksCommitArgs Empty => new GetStacksCommitArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksCommitArgs.cs b/sdk/dotnet/Inputs/GetStacksCommitArgs.cs new file mode 100644 index 0000000..6e18223 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksCommitArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksCommitInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksCommitInputArgs() + { + } + public static new GetStacksCommitInputArgs Empty => new GetStacksCommitInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksLabel.cs b/sdk/dotnet/Inputs/GetStacksLabel.cs new file mode 100644 index 0000000..5d5f9c6 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksLabel.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksLabelArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksLabelArgs() + { + } + public static new GetStacksLabelArgs Empty => new GetStacksLabelArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksLabelArgs.cs b/sdk/dotnet/Inputs/GetStacksLabelArgs.cs new file mode 100644 index 0000000..766a5dd --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksLabelArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksLabelInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksLabelInputArgs() + { + } + public static new GetStacksLabelInputArgs Empty => new GetStacksLabelInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksLocked.cs b/sdk/dotnet/Inputs/GetStacksLocked.cs new file mode 100644 index 0000000..b78b482 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksLocked.cs @@ -0,0 +1,23 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksLockedArgs : global::Pulumi.InvokeArgs + { + [Input("equals")] + public bool? Equals { get; set; } + + public GetStacksLockedArgs() + { + } + public static new GetStacksLockedArgs Empty => new GetStacksLockedArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksLockedArgs.cs b/sdk/dotnet/Inputs/GetStacksLockedArgs.cs new file mode 100644 index 0000000..cc3d4a0 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksLockedArgs.cs @@ -0,0 +1,23 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksLockedInputArgs : global::Pulumi.ResourceArgs + { + [Input("equals")] + public Input? Equals { get; set; } + + public GetStacksLockedInputArgs() + { + } + public static new GetStacksLockedInputArgs Empty => new GetStacksLockedInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksName.cs b/sdk/dotnet/Inputs/GetStacksName.cs new file mode 100644 index 0000000..b09b575 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksName.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksNameArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksNameArgs() + { + } + public static new GetStacksNameArgs Empty => new GetStacksNameArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksNameArgs.cs b/sdk/dotnet/Inputs/GetStacksNameArgs.cs new file mode 100644 index 0000000..4ab69dd --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksNameArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksNameInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksNameInputArgs() + { + } + public static new GetStacksNameInputArgs Empty => new GetStacksNameInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksProjectRoot.cs b/sdk/dotnet/Inputs/GetStacksProjectRoot.cs new file mode 100644 index 0000000..181c777 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksProjectRoot.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksProjectRootArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksProjectRootArgs() + { + } + public static new GetStacksProjectRootArgs Empty => new GetStacksProjectRootArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksProjectRootArgs.cs b/sdk/dotnet/Inputs/GetStacksProjectRootArgs.cs new file mode 100644 index 0000000..43ff6dd --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksProjectRootArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksProjectRootInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksProjectRootInputArgs() + { + } + public static new GetStacksProjectRootInputArgs Empty => new GetStacksProjectRootInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksRepository.cs b/sdk/dotnet/Inputs/GetStacksRepository.cs new file mode 100644 index 0000000..f56cfef --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksRepository.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksRepositoryArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksRepositoryArgs() + { + } + public static new GetStacksRepositoryArgs Empty => new GetStacksRepositoryArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksRepositoryArgs.cs b/sdk/dotnet/Inputs/GetStacksRepositoryArgs.cs new file mode 100644 index 0000000..7efc56a --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksRepositoryArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksRepositoryInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksRepositoryInputArgs() + { + } + public static new GetStacksRepositoryInputArgs Empty => new GetStacksRepositoryInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksState.cs b/sdk/dotnet/Inputs/GetStacksState.cs new file mode 100644 index 0000000..7e2392a --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksState.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksStateArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksStateArgs() + { + } + public static new GetStacksStateArgs Empty => new GetStacksStateArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksStateArgs.cs b/sdk/dotnet/Inputs/GetStacksStateArgs.cs new file mode 100644 index 0000000..123296b --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksStateArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksStateInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksStateInputArgs() + { + } + public static new GetStacksStateInputArgs Empty => new GetStacksStateInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksVendor.cs b/sdk/dotnet/Inputs/GetStacksVendor.cs new file mode 100644 index 0000000..4cdae6e --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksVendor.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksVendorArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksVendorArgs() + { + } + public static new GetStacksVendorArgs Empty => new GetStacksVendorArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksVendorArgs.cs b/sdk/dotnet/Inputs/GetStacksVendorArgs.cs new file mode 100644 index 0000000..e24105c --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksVendorArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksVendorInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksVendorInputArgs() + { + } + public static new GetStacksVendorInputArgs Empty => new GetStacksVendorInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksWorkerPool.cs b/sdk/dotnet/Inputs/GetStacksWorkerPool.cs new file mode 100644 index 0000000..f9411e3 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksWorkerPool.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksWorkerPoolArgs : global::Pulumi.InvokeArgs + { + [Input("anyOfs", required: true)] + private List? _anyOfs; + public List AnyOfs + { + get => _anyOfs ?? (_anyOfs = new List()); + set => _anyOfs = value; + } + + public GetStacksWorkerPoolArgs() + { + } + public static new GetStacksWorkerPoolArgs Empty => new GetStacksWorkerPoolArgs(); + } +} diff --git a/sdk/dotnet/Inputs/GetStacksWorkerPoolArgs.cs b/sdk/dotnet/Inputs/GetStacksWorkerPoolArgs.cs new file mode 100644 index 0000000..e9aa2a1 --- /dev/null +++ b/sdk/dotnet/Inputs/GetStacksWorkerPoolArgs.cs @@ -0,0 +1,28 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class GetStacksWorkerPoolInputArgs : global::Pulumi.ResourceArgs + { + [Input("anyOfs", required: true)] + private InputList? _anyOfs; + public InputList AnyOfs + { + get => _anyOfs ?? (_anyOfs = new InputList()); + set => _anyOfs = value; + } + + public GetStacksWorkerPoolInputArgs() + { + } + public static new GetStacksWorkerPoolInputArgs Empty => new GetStacksWorkerPoolInputArgs(); + } +} diff --git a/sdk/dotnet/Inputs/IdpGroupMappingPolicyArgs.cs b/sdk/dotnet/Inputs/IdpGroupMappingPolicyArgs.cs new file mode 100644 index 0000000..226c00d --- /dev/null +++ b/sdk/dotnet/Inputs/IdpGroupMappingPolicyArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class IdpGroupMappingPolicyArgs : global::Pulumi.ResourceArgs + { + /// + /// Type of access to the space. Possible values are: READ, WRITE, ADMIN + /// + [Input("role", required: true)] + public Input Role { get; set; } = null!; + + /// + /// ID (slug) of the space the user group has access to + /// + [Input("spaceId", required: true)] + public Input SpaceId { get; set; } = null!; + + public IdpGroupMappingPolicyArgs() + { + } + public static new IdpGroupMappingPolicyArgs Empty => new IdpGroupMappingPolicyArgs(); + } +} diff --git a/sdk/dotnet/Inputs/IdpGroupMappingPolicyGetArgs.cs b/sdk/dotnet/Inputs/IdpGroupMappingPolicyGetArgs.cs new file mode 100644 index 0000000..ea60818 --- /dev/null +++ b/sdk/dotnet/Inputs/IdpGroupMappingPolicyGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class IdpGroupMappingPolicyGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Type of access to the space. Possible values are: READ, WRITE, ADMIN + /// + [Input("role", required: true)] + public Input Role { get; set; } = null!; + + /// + /// ID (slug) of the space the user group has access to + /// + [Input("spaceId", required: true)] + public Input SpaceId { get; set; } = null!; + + public IdpGroupMappingPolicyGetArgs() + { + } + public static new IdpGroupMappingPolicyGetArgs Empty => new IdpGroupMappingPolicyGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/StackKubernetesArgs.cs b/sdk/dotnet/Inputs/StackKubernetesArgs.cs index 00c1d57..c40c7f3 100644 --- a/sdk/dotnet/Inputs/StackKubernetesArgs.cs +++ b/sdk/dotnet/Inputs/StackKubernetesArgs.cs @@ -12,6 +12,12 @@ namespace Pulumi.Spacelift.Inputs public sealed class StackKubernetesArgs : global::Pulumi.ResourceArgs { + /// + /// Kubectl version. + /// + [Input("kubectlVersion")] + public Input? KubectlVersion { get; set; } + /// /// Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. /// diff --git a/sdk/dotnet/Inputs/StackKubernetesGetArgs.cs b/sdk/dotnet/Inputs/StackKubernetesGetArgs.cs index 4cb425d..cd79dbf 100644 --- a/sdk/dotnet/Inputs/StackKubernetesGetArgs.cs +++ b/sdk/dotnet/Inputs/StackKubernetesGetArgs.cs @@ -12,6 +12,12 @@ namespace Pulumi.Spacelift.Inputs public sealed class StackKubernetesGetArgs : global::Pulumi.ResourceArgs { + /// + /// Kubectl version. + /// + [Input("kubectlVersion")] + public Input? KubectlVersion { get; set; } + /// /// Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. /// diff --git a/sdk/dotnet/Inputs/StackRawGitArgs.cs b/sdk/dotnet/Inputs/StackRawGitArgs.cs new file mode 100644 index 0000000..80fd8ba --- /dev/null +++ b/sdk/dotnet/Inputs/StackRawGitArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class StackRawGitArgs : global::Pulumi.ResourceArgs + { + /// + /// User-friendly namespace for the repository, this is for cosmetic purposes only + /// + [Input("namespace", required: true)] + public Input Namespace { get; set; } = null!; + + /// + /// HTTPS URL of the Git repository + /// + [Input("url", required: true)] + public Input Url { get; set; } = null!; + + public StackRawGitArgs() + { + } + public static new StackRawGitArgs Empty => new StackRawGitArgs(); + } +} diff --git a/sdk/dotnet/Inputs/StackRawGitGetArgs.cs b/sdk/dotnet/Inputs/StackRawGitGetArgs.cs new file mode 100644 index 0000000..5d0c7fb --- /dev/null +++ b/sdk/dotnet/Inputs/StackRawGitGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class StackRawGitGetArgs : global::Pulumi.ResourceArgs + { + /// + /// User-friendly namespace for the repository, this is for cosmetic purposes only + /// + [Input("namespace", required: true)] + public Input Namespace { get; set; } = null!; + + /// + /// HTTPS URL of the Git repository + /// + [Input("url", required: true)] + public Input Url { get; set; } = null!; + + public StackRawGitGetArgs() + { + } + public static new StackRawGitGetArgs Empty => new StackRawGitGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/StackTerragruntArgs.cs b/sdk/dotnet/Inputs/StackTerragruntArgs.cs new file mode 100644 index 0000000..009eb1f --- /dev/null +++ b/sdk/dotnet/Inputs/StackTerragruntArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class StackTerragruntArgs : global::Pulumi.ResourceArgs + { + [Input("terraformVersion")] + public Input? TerraformVersion { get; set; } + + /// + /// Terragrunt version. + /// + [Input("terragruntVersion")] + public Input? TerragruntVersion { get; set; } + + /// + /// Whether to use `terragrunt run-all` instead of `terragrunt`. + /// + [Input("useRunAll")] + public Input? UseRunAll { get; set; } + + [Input("useSmartSanitization")] + public Input? UseSmartSanitization { get; set; } + + public StackTerragruntArgs() + { + } + public static new StackTerragruntArgs Empty => new StackTerragruntArgs(); + } +} diff --git a/sdk/dotnet/Inputs/StackTerragruntGetArgs.cs b/sdk/dotnet/Inputs/StackTerragruntGetArgs.cs new file mode 100644 index 0000000..3c38be7 --- /dev/null +++ b/sdk/dotnet/Inputs/StackTerragruntGetArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class StackTerragruntGetArgs : global::Pulumi.ResourceArgs + { + [Input("terraformVersion")] + public Input? TerraformVersion { get; set; } + + /// + /// Terragrunt version. + /// + [Input("terragruntVersion")] + public Input? TerragruntVersion { get; set; } + + /// + /// Whether to use `terragrunt run-all` instead of `terragrunt`. + /// + [Input("useRunAll")] + public Input? UseRunAll { get; set; } + + [Input("useSmartSanitization")] + public Input? UseSmartSanitization { get; set; } + + public StackTerragruntGetArgs() + { + } + public static new StackTerragruntGetArgs Empty => new StackTerragruntGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/UserPolicyArgs.cs b/sdk/dotnet/Inputs/UserPolicyArgs.cs new file mode 100644 index 0000000..fdc3832 --- /dev/null +++ b/sdk/dotnet/Inputs/UserPolicyArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class UserPolicyArgs : global::Pulumi.ResourceArgs + { + /// + /// Type of access to the space. Possible values are: READ, WRITE, ADMIN + /// + [Input("role", required: true)] + public Input Role { get; set; } = null!; + + /// + /// ID (slug) of the space the user has access to + /// + [Input("spaceId", required: true)] + public Input SpaceId { get; set; } = null!; + + public UserPolicyArgs() + { + } + public static new UserPolicyArgs Empty => new UserPolicyArgs(); + } +} diff --git a/sdk/dotnet/Inputs/UserPolicyGetArgs.cs b/sdk/dotnet/Inputs/UserPolicyGetArgs.cs new file mode 100644 index 0000000..ff1e1b0 --- /dev/null +++ b/sdk/dotnet/Inputs/UserPolicyGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Inputs +{ + + public sealed class UserPolicyGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Type of access to the space. Possible values are: READ, WRITE, ADMIN + /// + [Input("role", required: true)] + public Input Role { get; set; } = null!; + + /// + /// ID (slug) of the space the user has access to + /// + [Input("spaceId", required: true)] + public Input SpaceId { get; set; } = null!; + + public UserPolicyGetArgs() + { + } + public static new UserPolicyGetArgs Empty => new UserPolicyGetArgs(); + } +} diff --git a/sdk/dotnet/Module.cs b/sdk/dotnet/Module.cs index 930a896..93879e6 100644 --- a/sdk/dotnet/Module.cs +++ b/sdk/dotnet/Module.cs @@ -14,6 +14,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -93,6 +94,12 @@ public partial class Module : global::Pulumi.CustomResource [Output("description")] public Output Description { get; private set; } = null!; + /// + /// Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + /// + [Output("enableLocalPreview")] + public Output EnableLocalPreview { get; private set; } = null!; + /// /// GitHub Enterprise (self-hosted) VCS settings /// @@ -155,11 +162,17 @@ public partial class Module : global::Pulumi.CustomResource public Output TerraformProvider { get; private set; } = null!; /// - /// ID of the worker pool to use + /// ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. /// [Output("workerPoolId")] public Output WorkerPoolId { get; private set; } = null!; + /// + /// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + /// + [Output("workflowTool")] + public Output WorkflowTool { get; private set; } = null!; + /// /// Create a Module resource with the given unique name, arguments, and options. @@ -243,6 +256,12 @@ public sealed class ModuleArgs : global::Pulumi.ResourceArgs [Input("description")] public Input? Description { get; set; } + /// + /// Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + /// + [Input("enableLocalPreview")] + public Input? EnableLocalPreview { get; set; } + /// /// GitHub Enterprise (self-hosted) VCS settings /// @@ -316,11 +335,17 @@ public InputList SharedAccounts public Input? TerraformProvider { get; set; } /// - /// ID of the worker pool to use + /// ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. /// [Input("workerPoolId")] public Input? WorkerPoolId { get; set; } + /// + /// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + /// + [Input("workflowTool")] + public Input? WorkflowTool { get; set; } + public ModuleArgs() { } @@ -371,6 +396,12 @@ public sealed class ModuleState : global::Pulumi.ResourceArgs [Input("description")] public Input? Description { get; set; } + /// + /// Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + /// + [Input("enableLocalPreview")] + public Input? EnableLocalPreview { get; set; } + /// /// GitHub Enterprise (self-hosted) VCS settings /// @@ -444,11 +475,17 @@ public InputList SharedAccounts public Input? TerraformProvider { get; set; } /// - /// ID of the worker pool to use + /// ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. /// [Input("workerPoolId")] public Input? WorkerPoolId { get; set; } + /// + /// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + /// + [Input("workflowTool")] + public Input? WorkflowTool { get; set; } + public ModuleState() { } diff --git a/sdk/dotnet/Mountedfile.cs b/sdk/dotnet/Mountedfile.cs index d57e3e8..7f67584 100644 --- a/sdk/dotnet/Mountedfile.cs +++ b/sdk/dotnet/Mountedfile.cs @@ -18,11 +18,12 @@ namespace Pulumi.Spacelift /// using System; /// using System.Collections.Generic; /// using System.IO; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// /// private static string ReadFileBase64(string path) { - /// return Convert.ToBase64String(Encoding.UTF8.GetBytes(File.ReadAllText(path))) + /// return Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(File.ReadAllText(path))); /// } /// /// return await Deployment.RunAsync(() => @@ -137,6 +138,10 @@ private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? { Version = Utilities.Version, PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + AdditionalSecretOutputs = + { + "content", + }, }; var merged = CustomResourceOptions.Merge(defaultOptions, options); // Override the ID if one was specified for consistency with other language SDKs. @@ -160,11 +165,21 @@ public static Mountedfile Get(string name, Input id, MountedfileState? s public sealed class MountedfileArgs : global::Pulumi.ResourceArgs { + [Input("content", required: true)] + private Input? _content; + /// /// Content of the mounted file encoded using Base-64 /// - [Input("content", required: true)] - public Input Content { get; set; } = null!; + public Input? Content + { + get => _content; + set + { + var emptySecret = Output.CreateSecret(0); + _content = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// ID of the context on which the mounted file is defined @@ -210,11 +225,21 @@ public sealed class MountedfileState : global::Pulumi.ResourceArgs [Input("checksum")] public Input? Checksum { get; set; } + [Input("content")] + private Input? _content; + /// /// Content of the mounted file encoded using Base-64 /// - [Input("content")] - public Input? Content { get; set; } + public Input? Content + { + get => _content; + set + { + var emptySecret = Output.CreateSecret(0); + _content = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// ID of the context on which the mounted file is defined diff --git a/sdk/dotnet/NamedWebhook.cs b/sdk/dotnet/NamedWebhook.cs new file mode 100644 index 0000000..58b40b7 --- /dev/null +++ b/sdk/dotnet/NamedWebhook.cs @@ -0,0 +1,222 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + /// + [SpaceliftResourceType("spacelift:index/namedWebhook:NamedWebhook")] + public partial class NamedWebhook : global::Pulumi.CustomResource + { + /// + /// enables or disables sending webhooks. + /// + [Output("enabled")] + public Output Enabled { get; private set; } = null!; + + /// + /// endpoint to send the requests to + /// + [Output("endpoint")] + public Output Endpoint { get; private set; } = null!; + + /// + /// labels for the webhook to use when referring in policies or filtering them + /// + [Output("labels")] + public Output> Labels { get; private set; } = null!; + + /// + /// the name for the webhook which will also be used to generate the id + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + /// + [Output("secret")] + public Output Secret { get; private set; } = null!; + + /// + /// ID of the space the webhook is in + /// + [Output("spaceId")] + public Output SpaceId { get; private set; } = null!; + + + /// + /// Create a NamedWebhook resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public NamedWebhook(string name, NamedWebhookArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/namedWebhook:NamedWebhook", name, args ?? new NamedWebhookArgs(), MakeResourceOptions(options, "")) + { + } + + private NamedWebhook(string name, Input id, NamedWebhookState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/namedWebhook:NamedWebhook", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + AdditionalSecretOutputs = + { + "secret", + }, + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing NamedWebhook resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static NamedWebhook Get(string name, Input id, NamedWebhookState? state = null, CustomResourceOptions? options = null) + { + return new NamedWebhook(name, id, state, options); + } + } + + public sealed class NamedWebhookArgs : global::Pulumi.ResourceArgs + { + /// + /// enables or disables sending webhooks. + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + /// + /// endpoint to send the requests to + /// + [Input("endpoint", required: true)] + public Input Endpoint { get; set; } = null!; + + [Input("labels")] + private InputList? _labels; + + /// + /// labels for the webhook to use when referring in policies or filtering them + /// + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + + /// + /// the name for the webhook which will also be used to generate the id + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("secret")] + private Input? _secret; + + /// + /// secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + /// + public Input? Secret + { + get => _secret; + set + { + var emptySecret = Output.CreateSecret(0); + _secret = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// ID of the space the webhook is in + /// + [Input("spaceId", required: true)] + public Input SpaceId { get; set; } = null!; + + public NamedWebhookArgs() + { + } + public static new NamedWebhookArgs Empty => new NamedWebhookArgs(); + } + + public sealed class NamedWebhookState : global::Pulumi.ResourceArgs + { + /// + /// enables or disables sending webhooks. + /// + [Input("enabled")] + public Input? Enabled { get; set; } + + /// + /// endpoint to send the requests to + /// + [Input("endpoint")] + public Input? Endpoint { get; set; } + + [Input("labels")] + private InputList? _labels; + + /// + /// labels for the webhook to use when referring in policies or filtering them + /// + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + + /// + /// the name for the webhook which will also be used to generate the id + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("secret")] + private Input? _secret; + + /// + /// secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + /// + public Input? Secret + { + get => _secret; + set + { + var emptySecret = Output.CreateSecret(0); + _secret = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// ID of the space the webhook is in + /// + [Input("spaceId")] + public Input? SpaceId { get; set; } + + public NamedWebhookState() + { + } + public static new NamedWebhookState Empty => new NamedWebhookState(); + } +} diff --git a/sdk/dotnet/NamedWebhookSecretHeader.cs b/sdk/dotnet/NamedWebhookSecretHeader.cs new file mode 100644 index 0000000..88a5f9e --- /dev/null +++ b/sdk/dotnet/NamedWebhookSecretHeader.cs @@ -0,0 +1,156 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.NamedWebhookSecretHeader` represents secret key value combination used as a custom headerwhen delivering webhook requests. It depends on `spacelift.NamedWebhook` resource which should exist. + /// + [SpaceliftResourceType("spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader")] + public partial class NamedWebhookSecretHeader : global::Pulumi.CustomResource + { + /// + /// key for the header + /// + [Output("key")] + public Output Key { get; private set; } = null!; + + /// + /// value for the header + /// + [Output("value")] + public Output Value { get; private set; } = null!; + + /// + /// ID of the stack on which the environment variable is defined + /// + [Output("webhookId")] + public Output WebhookId { get; private set; } = null!; + + + /// + /// Create a NamedWebhookSecretHeader resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public NamedWebhookSecretHeader(string name, NamedWebhookSecretHeaderArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader", name, args ?? new NamedWebhookSecretHeaderArgs(), MakeResourceOptions(options, "")) + { + } + + private NamedWebhookSecretHeader(string name, Input id, NamedWebhookSecretHeaderState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + AdditionalSecretOutputs = + { + "value", + }, + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing NamedWebhookSecretHeader resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static NamedWebhookSecretHeader Get(string name, Input id, NamedWebhookSecretHeaderState? state = null, CustomResourceOptions? options = null) + { + return new NamedWebhookSecretHeader(name, id, state, options); + } + } + + public sealed class NamedWebhookSecretHeaderArgs : global::Pulumi.ResourceArgs + { + /// + /// key for the header + /// + [Input("key", required: true)] + public Input Key { get; set; } = null!; + + [Input("value", required: true)] + private Input? _value; + + /// + /// value for the header + /// + public Input? Value + { + get => _value; + set + { + var emptySecret = Output.CreateSecret(0); + _value = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// ID of the stack on which the environment variable is defined + /// + [Input("webhookId", required: true)] + public Input WebhookId { get; set; } = null!; + + public NamedWebhookSecretHeaderArgs() + { + } + public static new NamedWebhookSecretHeaderArgs Empty => new NamedWebhookSecretHeaderArgs(); + } + + public sealed class NamedWebhookSecretHeaderState : global::Pulumi.ResourceArgs + { + /// + /// key for the header + /// + [Input("key")] + public Input? Key { get; set; } + + [Input("value")] + private Input? _value; + + /// + /// value for the header + /// + public Input? Value + { + get => _value; + set + { + var emptySecret = Output.CreateSecret(0); + _value = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// ID of the stack on which the environment variable is defined + /// + [Input("webhookId")] + public Input? WebhookId { get; set; } + + public NamedWebhookSecretHeaderState() + { + } + public static new NamedWebhookSecretHeaderState Empty => new NamedWebhookSecretHeaderState(); + } +} diff --git a/sdk/dotnet/Outputs/GetAwsIntegrationsIntegrationResult.cs b/sdk/dotnet/Outputs/GetAwsIntegrationsIntegrationResult.cs new file mode 100644 index 0000000..57df016 --- /dev/null +++ b/sdk/dotnet/Outputs/GetAwsIntegrationsIntegrationResult.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetAwsIntegrationsIntegrationResult + { + public readonly int DurationSeconds; + public readonly string ExternalId; + public readonly bool GenerateCredentialsInWorker; + public readonly string IntegrationId; + public readonly ImmutableArray Labels; + public readonly string Name; + public readonly string RoleArn; + public readonly string SpaceId; + + [OutputConstructor] + private GetAwsIntegrationsIntegrationResult( + int durationSeconds, + + string externalId, + + bool generateCredentialsInWorker, + + string integrationId, + + ImmutableArray labels, + + string name, + + string roleArn, + + string spaceId) + { + DurationSeconds = durationSeconds; + ExternalId = externalId; + GenerateCredentialsInWorker = generateCredentialsInWorker; + IntegrationId = integrationId; + Labels = labels; + Name = name; + RoleArn = roleArn; + SpaceId = spaceId; + } + } +} diff --git a/sdk/dotnet/Outputs/GetAzureIntegrationsIntegrationResult.cs b/sdk/dotnet/Outputs/GetAzureIntegrationsIntegrationResult.cs new file mode 100644 index 0000000..9f0427d --- /dev/null +++ b/sdk/dotnet/Outputs/GetAzureIntegrationsIntegrationResult.cs @@ -0,0 +1,61 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetAzureIntegrationsIntegrationResult + { + public readonly bool AdminConsentProvided; + public readonly string AdminConsentUrl; + public readonly string ApplicationId; + public readonly string DefaultSubscriptionId; + public readonly string DisplayName; + public readonly string IntegrationId; + public readonly ImmutableArray Labels; + public readonly string Name; + public readonly string SpaceId; + public readonly string TenantId; + + [OutputConstructor] + private GetAzureIntegrationsIntegrationResult( + bool adminConsentProvided, + + string adminConsentUrl, + + string applicationId, + + string defaultSubscriptionId, + + string displayName, + + string integrationId, + + ImmutableArray labels, + + string name, + + string spaceId, + + string tenantId) + { + AdminConsentProvided = adminConsentProvided; + AdminConsentUrl = adminConsentUrl; + ApplicationId = applicationId; + DefaultSubscriptionId = defaultSubscriptionId; + DisplayName = displayName; + IntegrationId = integrationId; + Labels = labels; + Name = name; + SpaceId = spaceId; + TenantId = tenantId; + } + } +} diff --git a/sdk/dotnet/Outputs/GetContextsContextResult.cs b/sdk/dotnet/Outputs/GetContextsContextResult.cs new file mode 100644 index 0000000..ce53d13 --- /dev/null +++ b/sdk/dotnet/Outputs/GetContextsContextResult.cs @@ -0,0 +1,41 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetContextsContextResult + { + public readonly string ContextId; + public readonly string Description; + public readonly ImmutableArray Labels; + public readonly string Name; + public readonly string SpaceId; + + [OutputConstructor] + private GetContextsContextResult( + string contextId, + + string description, + + ImmutableArray labels, + + string name, + + string spaceId) + { + ContextId = contextId; + Description = description; + Labels = labels; + Name = name; + SpaceId = spaceId; + } + } +} diff --git a/sdk/dotnet/Outputs/GetContextsLabelResult.cs b/sdk/dotnet/Outputs/GetContextsLabelResult.cs new file mode 100644 index 0000000..43cabfa --- /dev/null +++ b/sdk/dotnet/Outputs/GetContextsLabelResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetContextsLabelResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetContextsLabelResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetPoliciesPolicyResult.cs b/sdk/dotnet/Outputs/GetPoliciesPolicyResult.cs index 243caba..012eca3 100644 --- a/sdk/dotnet/Outputs/GetPoliciesPolicyResult.cs +++ b/sdk/dotnet/Outputs/GetPoliciesPolicyResult.cs @@ -13,19 +13,10 @@ namespace Pulumi.Spacelift.Outputs [OutputType] public sealed class GetPoliciesPolicyResult { - /// - /// The ID of this resource. - /// public readonly string Id; - /// - /// required labels to match - /// public readonly ImmutableArray Labels; public readonly string Name; public readonly string SpaceId; - /// - /// required policy type - /// public readonly string Type; [OutputConstructor] diff --git a/sdk/dotnet/Outputs/GetSpacesSpaceResult.cs b/sdk/dotnet/Outputs/GetSpacesSpaceResult.cs new file mode 100644 index 0000000..3fe4c67 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSpacesSpaceResult.cs @@ -0,0 +1,45 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetSpacesSpaceResult + { + public readonly string Description; + public readonly bool InheritEntities; + public readonly ImmutableArray Labels; + public readonly string Name; + public readonly string ParentSpaceId; + public readonly string SpaceId; + + [OutputConstructor] + private GetSpacesSpaceResult( + string description, + + bool inheritEntities, + + ImmutableArray labels, + + string name, + + string parentSpaceId, + + string spaceId) + { + Description = description; + InheritEntities = inheritEntities; + Labels = labels; + Name = name; + ParentSpaceId = parentSpaceId; + SpaceId = spaceId; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStackKuberneteResult.cs b/sdk/dotnet/Outputs/GetStackKuberneteResult.cs index 1417f01..dbb6812 100644 --- a/sdk/dotnet/Outputs/GetStackKuberneteResult.cs +++ b/sdk/dotnet/Outputs/GetStackKuberneteResult.cs @@ -13,11 +13,16 @@ namespace Pulumi.Spacelift.Outputs [OutputType] public sealed class GetStackKuberneteResult { + public readonly string KubectlVersion; public readonly string Namespace; [OutputConstructor] - private GetStackKuberneteResult(string @namespace) + private GetStackKuberneteResult( + string kubectlVersion, + + string @namespace) { + KubectlVersion = kubectlVersion; Namespace = @namespace; } } diff --git a/sdk/dotnet/Outputs/GetStackRawGitResult.cs b/sdk/dotnet/Outputs/GetStackRawGitResult.cs new file mode 100644 index 0000000..a71b06a --- /dev/null +++ b/sdk/dotnet/Outputs/GetStackRawGitResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStackRawGitResult + { + public readonly string Namespace; + public readonly string Url; + + [OutputConstructor] + private GetStackRawGitResult( + string @namespace, + + string url) + { + Namespace = @namespace; + Url = url; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksAdministrativeResult.cs b/sdk/dotnet/Outputs/GetStacksAdministrativeResult.cs new file mode 100644 index 0000000..4c83845 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksAdministrativeResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksAdministrativeResult + { + public readonly bool? Equals; + + [OutputConstructor] + private GetStacksAdministrativeResult(bool? equals) + { + Equals = equals; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksBranchResult.cs b/sdk/dotnet/Outputs/GetStacksBranchResult.cs new file mode 100644 index 0000000..901d272 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksBranchResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksBranchResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksBranchResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksCommitResult.cs b/sdk/dotnet/Outputs/GetStacksCommitResult.cs new file mode 100644 index 0000000..6b8ee76 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksCommitResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksCommitResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksCommitResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksLabelResult.cs b/sdk/dotnet/Outputs/GetStacksLabelResult.cs new file mode 100644 index 0000000..c31d012 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksLabelResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksLabelResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksLabelResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksLockedResult.cs b/sdk/dotnet/Outputs/GetStacksLockedResult.cs new file mode 100644 index 0000000..ba661aa --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksLockedResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksLockedResult + { + public readonly bool? Equals; + + [OutputConstructor] + private GetStacksLockedResult(bool? equals) + { + Equals = equals; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksNameResult.cs b/sdk/dotnet/Outputs/GetStacksNameResult.cs new file mode 100644 index 0000000..7925cac --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksNameResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksNameResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksNameResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksProjectRootResult.cs b/sdk/dotnet/Outputs/GetStacksProjectRootResult.cs new file mode 100644 index 0000000..dfa7a12 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksProjectRootResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksProjectRootResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksProjectRootResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksRepositoryResult.cs b/sdk/dotnet/Outputs/GetStacksRepositoryResult.cs new file mode 100644 index 0000000..aab3861 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksRepositoryResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksRepositoryResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksRepositoryResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackAnsibleResult.cs b/sdk/dotnet/Outputs/GetStacksStackAnsibleResult.cs new file mode 100644 index 0000000..a175801 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackAnsibleResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackAnsibleResult + { + public readonly string Playbook; + + [OutputConstructor] + private GetStacksStackAnsibleResult(string playbook) + { + Playbook = playbook; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackAzureDevopResult.cs b/sdk/dotnet/Outputs/GetStacksStackAzureDevopResult.cs new file mode 100644 index 0000000..d3c2b5f --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackAzureDevopResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackAzureDevopResult + { + public readonly string Project; + + [OutputConstructor] + private GetStacksStackAzureDevopResult(string project) + { + Project = project; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackBitbucketCloudResult.cs b/sdk/dotnet/Outputs/GetStacksStackBitbucketCloudResult.cs new file mode 100644 index 0000000..39a0400 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackBitbucketCloudResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackBitbucketCloudResult + { + public readonly string Namespace; + + [OutputConstructor] + private GetStacksStackBitbucketCloudResult(string @namespace) + { + Namespace = @namespace; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackBitbucketDatacenterResult.cs b/sdk/dotnet/Outputs/GetStacksStackBitbucketDatacenterResult.cs new file mode 100644 index 0000000..1872138 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackBitbucketDatacenterResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackBitbucketDatacenterResult + { + public readonly string Namespace; + + [OutputConstructor] + private GetStacksStackBitbucketDatacenterResult(string @namespace) + { + Namespace = @namespace; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackCloudformationResult.cs b/sdk/dotnet/Outputs/GetStacksStackCloudformationResult.cs new file mode 100644 index 0000000..15e1c39 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackCloudformationResult.cs @@ -0,0 +1,37 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackCloudformationResult + { + public readonly string EntryTemplateFile; + public readonly string Region; + public readonly string StackName; + public readonly string TemplateBucket; + + [OutputConstructor] + private GetStacksStackCloudformationResult( + string entryTemplateFile, + + string region, + + string stackName, + + string templateBucket) + { + EntryTemplateFile = entryTemplateFile; + Region = region; + StackName = stackName; + TemplateBucket = templateBucket; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackGithubEnterpriseResult.cs b/sdk/dotnet/Outputs/GetStacksStackGithubEnterpriseResult.cs new file mode 100644 index 0000000..976a042 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackGithubEnterpriseResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackGithubEnterpriseResult + { + public readonly string Namespace; + + [OutputConstructor] + private GetStacksStackGithubEnterpriseResult(string @namespace) + { + Namespace = @namespace; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackGitlabResult.cs b/sdk/dotnet/Outputs/GetStacksStackGitlabResult.cs new file mode 100644 index 0000000..0ab239f --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackGitlabResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackGitlabResult + { + public readonly string Namespace; + + [OutputConstructor] + private GetStacksStackGitlabResult(string @namespace) + { + Namespace = @namespace; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackKuberneteResult.cs b/sdk/dotnet/Outputs/GetStacksStackKuberneteResult.cs new file mode 100644 index 0000000..d8182d7 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackKuberneteResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackKuberneteResult + { + public readonly string KubectlVersion; + public readonly string Namespace; + + [OutputConstructor] + private GetStacksStackKuberneteResult( + string kubectlVersion, + + string @namespace) + { + KubectlVersion = kubectlVersion; + Namespace = @namespace; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackPulumiResult.cs b/sdk/dotnet/Outputs/GetStacksStackPulumiResult.cs new file mode 100644 index 0000000..74c9044 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackPulumiResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackPulumiResult + { + public readonly string LoginUrl; + public readonly string StackName; + + [OutputConstructor] + private GetStacksStackPulumiResult( + string loginUrl, + + string stackName) + { + LoginUrl = loginUrl; + StackName = stackName; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackRawGitResult.cs b/sdk/dotnet/Outputs/GetStacksStackRawGitResult.cs new file mode 100644 index 0000000..a372c00 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackRawGitResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackRawGitResult + { + public readonly string Namespace; + public readonly string Url; + + [OutputConstructor] + private GetStacksStackRawGitResult( + string @namespace, + + string url) + { + Namespace = @namespace; + Url = url; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackResult.cs b/sdk/dotnet/Outputs/GetStacksStackResult.cs new file mode 100644 index 0000000..f62d03a --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackResult.cs @@ -0,0 +1,197 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackResult + { + public readonly bool Administrative; + public readonly ImmutableArray AfterApplies; + public readonly ImmutableArray AfterDestroys; + public readonly ImmutableArray AfterInits; + public readonly ImmutableArray AfterPerforms; + public readonly ImmutableArray AfterPlans; + public readonly ImmutableArray AfterRuns; + public readonly ImmutableArray Ansibles; + public readonly bool Autodeploy; + public readonly bool Autoretry; + public readonly string AwsAssumeRolePolicyStatement; + public readonly ImmutableArray AzureDevops; + public readonly ImmutableArray BeforeApplies; + public readonly ImmutableArray BeforeDestroys; + public readonly ImmutableArray BeforeInits; + public readonly ImmutableArray BeforePerforms; + public readonly ImmutableArray BeforePlans; + public readonly ImmutableArray BitbucketClouds; + public readonly ImmutableArray BitbucketDatacenters; + public readonly string Branch; + public readonly ImmutableArray Cloudformations; + public readonly string Description; + public readonly bool EnableLocalPreview; + public readonly ImmutableArray GithubEnterprises; + public readonly ImmutableArray Gitlabs; + public readonly ImmutableArray Kubernetes; + public readonly ImmutableArray Labels; + public readonly bool ManageState; + public readonly string Name; + public readonly string ProjectRoot; + public readonly bool ProtectFromDeletion; + public readonly ImmutableArray Pulumis; + public readonly ImmutableArray RawGits; + public readonly string Repository; + public readonly string RunnerImage; + public readonly ImmutableArray Showcases; + public readonly string SpaceId; + public readonly string StackId; + public readonly bool TerraformExternalStateAccess; + public readonly bool TerraformSmartSanitization; + public readonly string TerraformVersion; + public readonly string TerraformWorkflowTool; + public readonly string TerraformWorkspace; + public readonly string WorkerPoolId; + + [OutputConstructor] + private GetStacksStackResult( + bool administrative, + + ImmutableArray afterApplies, + + ImmutableArray afterDestroys, + + ImmutableArray afterInits, + + ImmutableArray afterPerforms, + + ImmutableArray afterPlans, + + ImmutableArray afterRuns, + + ImmutableArray ansibles, + + bool autodeploy, + + bool autoretry, + + string awsAssumeRolePolicyStatement, + + ImmutableArray azureDevops, + + ImmutableArray beforeApplies, + + ImmutableArray beforeDestroys, + + ImmutableArray beforeInits, + + ImmutableArray beforePerforms, + + ImmutableArray beforePlans, + + ImmutableArray bitbucketClouds, + + ImmutableArray bitbucketDatacenters, + + string branch, + + ImmutableArray cloudformations, + + string description, + + bool enableLocalPreview, + + ImmutableArray githubEnterprises, + + ImmutableArray gitlabs, + + ImmutableArray kubernetes, + + ImmutableArray labels, + + bool manageState, + + string name, + + string projectRoot, + + bool protectFromDeletion, + + ImmutableArray pulumis, + + ImmutableArray rawGits, + + string repository, + + string runnerImage, + + ImmutableArray showcases, + + string spaceId, + + string stackId, + + bool terraformExternalStateAccess, + + bool terraformSmartSanitization, + + string terraformVersion, + + string terraformWorkflowTool, + + string terraformWorkspace, + + string workerPoolId) + { + Administrative = administrative; + AfterApplies = afterApplies; + AfterDestroys = afterDestroys; + AfterInits = afterInits; + AfterPerforms = afterPerforms; + AfterPlans = afterPlans; + AfterRuns = afterRuns; + Ansibles = ansibles; + Autodeploy = autodeploy; + Autoretry = autoretry; + AwsAssumeRolePolicyStatement = awsAssumeRolePolicyStatement; + AzureDevops = azureDevops; + BeforeApplies = beforeApplies; + BeforeDestroys = beforeDestroys; + BeforeInits = beforeInits; + BeforePerforms = beforePerforms; + BeforePlans = beforePlans; + BitbucketClouds = bitbucketClouds; + BitbucketDatacenters = bitbucketDatacenters; + Branch = branch; + Cloudformations = cloudformations; + Description = description; + EnableLocalPreview = enableLocalPreview; + GithubEnterprises = githubEnterprises; + Gitlabs = gitlabs; + Kubernetes = kubernetes; + Labels = labels; + ManageState = manageState; + Name = name; + ProjectRoot = projectRoot; + ProtectFromDeletion = protectFromDeletion; + Pulumis = pulumis; + RawGits = rawGits; + Repository = repository; + RunnerImage = runnerImage; + Showcases = showcases; + SpaceId = spaceId; + StackId = stackId; + TerraformExternalStateAccess = terraformExternalStateAccess; + TerraformSmartSanitization = terraformSmartSanitization; + TerraformVersion = terraformVersion; + TerraformWorkflowTool = terraformWorkflowTool; + TerraformWorkspace = terraformWorkspace; + WorkerPoolId = workerPoolId; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStackShowcaseResult.cs b/sdk/dotnet/Outputs/GetStacksStackShowcaseResult.cs new file mode 100644 index 0000000..bb7895b --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStackShowcaseResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStackShowcaseResult + { + public readonly string Namespace; + + [OutputConstructor] + private GetStacksStackShowcaseResult(string @namespace) + { + Namespace = @namespace; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksStateResult.cs b/sdk/dotnet/Outputs/GetStacksStateResult.cs new file mode 100644 index 0000000..1fc6c9b --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksStateResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksStateResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksStateResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksVendorResult.cs b/sdk/dotnet/Outputs/GetStacksVendorResult.cs new file mode 100644 index 0000000..3368e87 --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksVendorResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksVendorResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksVendorResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetStacksWorkerPoolResult.cs b/sdk/dotnet/Outputs/GetStacksWorkerPoolResult.cs new file mode 100644 index 0000000..dd331be --- /dev/null +++ b/sdk/dotnet/Outputs/GetStacksWorkerPoolResult.cs @@ -0,0 +1,24 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class GetStacksWorkerPoolResult + { + public readonly ImmutableArray AnyOfs; + + [OutputConstructor] + private GetStacksWorkerPoolResult(ImmutableArray anyOfs) + { + AnyOfs = anyOfs; + } + } +} diff --git a/sdk/dotnet/Outputs/IdpGroupMappingPolicy.cs b/sdk/dotnet/Outputs/IdpGroupMappingPolicy.cs new file mode 100644 index 0000000..9431b71 --- /dev/null +++ b/sdk/dotnet/Outputs/IdpGroupMappingPolicy.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class IdpGroupMappingPolicy + { + /// + /// Type of access to the space. Possible values are: READ, WRITE, ADMIN + /// + public readonly string Role; + /// + /// ID (slug) of the space the user group has access to + /// + public readonly string SpaceId; + + [OutputConstructor] + private IdpGroupMappingPolicy( + string role, + + string spaceId) + { + Role = role; + SpaceId = spaceId; + } + } +} diff --git a/sdk/dotnet/Outputs/StackKubernetes.cs b/sdk/dotnet/Outputs/StackKubernetes.cs index dcbd161..c6cce22 100644 --- a/sdk/dotnet/Outputs/StackKubernetes.cs +++ b/sdk/dotnet/Outputs/StackKubernetes.cs @@ -13,14 +13,22 @@ namespace Pulumi.Spacelift.Outputs [OutputType] public sealed class StackKubernetes { + /// + /// Kubectl version. + /// + public readonly string? KubectlVersion; /// /// Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. /// public readonly string? Namespace; [OutputConstructor] - private StackKubernetes(string? @namespace) + private StackKubernetes( + string? kubectlVersion, + + string? @namespace) { + KubectlVersion = kubectlVersion; Namespace = @namespace; } } diff --git a/sdk/dotnet/Outputs/StackRawGit.cs b/sdk/dotnet/Outputs/StackRawGit.cs new file mode 100644 index 0000000..d6e37d6 --- /dev/null +++ b/sdk/dotnet/Outputs/StackRawGit.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class StackRawGit + { + /// + /// User-friendly namespace for the repository, this is for cosmetic purposes only + /// + public readonly string Namespace; + /// + /// HTTPS URL of the Git repository + /// + public readonly string Url; + + [OutputConstructor] + private StackRawGit( + string @namespace, + + string url) + { + Namespace = @namespace; + Url = url; + } + } +} diff --git a/sdk/dotnet/Outputs/StackTerragrunt.cs b/sdk/dotnet/Outputs/StackTerragrunt.cs new file mode 100644 index 0000000..51aa41b --- /dev/null +++ b/sdk/dotnet/Outputs/StackTerragrunt.cs @@ -0,0 +1,43 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class StackTerragrunt + { + public readonly string? TerraformVersion; + /// + /// Terragrunt version. + /// + public readonly string? TerragruntVersion; + /// + /// Whether to use `terragrunt run-all` instead of `terragrunt`. + /// + public readonly bool? UseRunAll; + public readonly bool? UseSmartSanitization; + + [OutputConstructor] + private StackTerragrunt( + string? terraformVersion, + + string? terragruntVersion, + + bool? useRunAll, + + bool? useSmartSanitization) + { + TerraformVersion = terraformVersion; + TerragruntVersion = terragruntVersion; + UseRunAll = useRunAll; + UseSmartSanitization = useSmartSanitization; + } + } +} diff --git a/sdk/dotnet/Outputs/UserPolicy.cs b/sdk/dotnet/Outputs/UserPolicy.cs new file mode 100644 index 0000000..8b64401 --- /dev/null +++ b/sdk/dotnet/Outputs/UserPolicy.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift.Outputs +{ + + [OutputType] + public sealed class UserPolicy + { + /// + /// Type of access to the space. Possible values are: READ, WRITE, ADMIN + /// + public readonly string Role; + /// + /// ID (slug) of the space the user has access to + /// + public readonly string SpaceId; + + [OutputConstructor] + private UserPolicy( + string role, + + string spaceId) + { + Role = role; + SpaceId = spaceId; + } + } +} diff --git a/sdk/dotnet/Policy.cs b/sdk/dotnet/Policy.cs index 59bdff5..c011bd5 100644 --- a/sdk/dotnet/Policy.cs +++ b/sdk/dotnet/Policy.cs @@ -17,6 +17,7 @@ namespace Pulumi.Spacelift /// ```csharp /// using System.Collections.Generic; /// using System.IO; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -74,7 +75,7 @@ public partial class Policy : global::Pulumi.CustomResource public Output SpaceId { get; private set; } = null!; /// - /// Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + /// Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). /// [Output("type")] public Output Type { get; private set; } = null!; @@ -153,7 +154,7 @@ public InputList Labels public Input? SpaceId { get; set; } /// - /// Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + /// Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). /// [Input("type", required: true)] public Input Type { get; set; } = null!; @@ -193,7 +194,7 @@ public InputList Labels public Input? SpaceId { get; set; } /// - /// Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + /// Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). /// [Input("type")] public Input? Type { get; set; } diff --git a/sdk/dotnet/PolicyAttachment.cs b/sdk/dotnet/PolicyAttachment.cs index fbb5b72..b13039d 100644 --- a/sdk/dotnet/PolicyAttachment.cs +++ b/sdk/dotnet/PolicyAttachment.cs @@ -17,6 +17,7 @@ namespace Pulumi.Spacelift /// ```csharp /// using System.Collections.Generic; /// using System.IO; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/Pulumi.Spacelift.csproj b/sdk/dotnet/Pulumi.Spacelift.csproj index 9222a17..6620d17 100644 --- a/sdk/dotnet/Pulumi.Spacelift.csproj +++ b/sdk/dotnet/Pulumi.Spacelift.csproj @@ -10,9 +10,8 @@ git://github.com/spacelift-io/pulumi-spacelift.git logo.png - netcoreapp3.1 + net6.0 enable - false @@ -39,7 +38,7 @@ - + diff --git a/sdk/dotnet/Run.cs b/sdk/dotnet/Run.cs index eccadb1..f0aa518 100644 --- a/sdk/dotnet/Run.cs +++ b/sdk/dotnet/Run.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/ScheduledDeleteTask.cs b/sdk/dotnet/ScheduledDeleteTask.cs new file mode 100644 index 0000000..06f52ec --- /dev/null +++ b/sdk/dotnet/ScheduledDeleteTask.cs @@ -0,0 +1,180 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var k8s_core = new Spacelift.Stack("k8s-core"); + /// + /// // ... + /// // at a given timestamp (unix) + /// var k8s_core_delete = new Spacelift.ScheduledDeleteTask("k8s-core-delete", new() + /// { + /// StackId = k8s_core.Id, + /// At = 1663336895, + /// DeleteResources = true, + /// }); + /// + /// }); + /// ``` + /// + /// ## Import + /// + /// ```sh + /// $ pulumi import spacelift:index/scheduledDeleteTask:ScheduledDeleteTask ireland-kubeconfig $STACK_ID/$SCHEDULED_DELETE_STACK_ID + /// ``` + /// + [SpaceliftResourceType("spacelift:index/scheduledDeleteTask:ScheduledDeleteTask")] + public partial class ScheduledDeleteTask : global::Pulumi.CustomResource + { + /// + /// Timestamp (unix timestamp) at which time the scheduling should happen. + /// + [Output("at")] + public Output At { get; private set; } = null!; + + /// + /// Indicates whether the resources of the stack should be deleted. + /// + [Output("deleteResources")] + public Output DeleteResources { get; private set; } = null!; + + /// + /// ID of the schedule + /// + [Output("scheduleId")] + public Output ScheduleId { get; private set; } = null!; + + /// + /// ID of the stack for which to set up scheduling + /// + [Output("stackId")] + public Output StackId { get; private set; } = null!; + + + /// + /// Create a ScheduledDeleteTask resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public ScheduledDeleteTask(string name, ScheduledDeleteTaskArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/scheduledDeleteTask:ScheduledDeleteTask", name, args ?? new ScheduledDeleteTaskArgs(), MakeResourceOptions(options, "")) + { + } + + private ScheduledDeleteTask(string name, Input id, ScheduledDeleteTaskState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/scheduledDeleteTask:ScheduledDeleteTask", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing ScheduledDeleteTask resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static ScheduledDeleteTask Get(string name, Input id, ScheduledDeleteTaskState? state = null, CustomResourceOptions? options = null) + { + return new ScheduledDeleteTask(name, id, state, options); + } + } + + public sealed class ScheduledDeleteTaskArgs : global::Pulumi.ResourceArgs + { + /// + /// Timestamp (unix timestamp) at which time the scheduling should happen. + /// + [Input("at", required: true)] + public Input At { get; set; } = null!; + + /// + /// Indicates whether the resources of the stack should be deleted. + /// + [Input("deleteResources")] + public Input? DeleteResources { get; set; } + + /// + /// ID of the schedule + /// + [Input("scheduleId")] + public Input? ScheduleId { get; set; } + + /// + /// ID of the stack for which to set up scheduling + /// + [Input("stackId", required: true)] + public Input StackId { get; set; } = null!; + + public ScheduledDeleteTaskArgs() + { + } + public static new ScheduledDeleteTaskArgs Empty => new ScheduledDeleteTaskArgs(); + } + + public sealed class ScheduledDeleteTaskState : global::Pulumi.ResourceArgs + { + /// + /// Timestamp (unix timestamp) at which time the scheduling should happen. + /// + [Input("at")] + public Input? At { get; set; } + + /// + /// Indicates whether the resources of the stack should be deleted. + /// + [Input("deleteResources")] + public Input? DeleteResources { get; set; } + + /// + /// ID of the schedule + /// + [Input("scheduleId")] + public Input? ScheduleId { get; set; } + + /// + /// ID of the stack for which to set up scheduling + /// + [Input("stackId")] + public Input? StackId { get; set; } + + public ScheduledDeleteTaskState() + { + } + public static new ScheduledDeleteTaskState Empty => new ScheduledDeleteTaskState(); + } +} diff --git a/sdk/dotnet/ScheduledTask.cs b/sdk/dotnet/ScheduledTask.cs new file mode 100644 index 0000000..08b06fa --- /dev/null +++ b/sdk/dotnet/ScheduledTask.cs @@ -0,0 +1,252 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.ScheduledTask` represents a scheduling configuration for a Stack. It will trigger task on the given schedule or timestamp + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var k8s_core = new Spacelift.Stack("k8s-core"); + /// + /// // ... + /// // create the resources of a stack on a given schedule + /// var k8s_core_create = new Spacelift.ScheduledTask("k8s-core-create", new() + /// { + /// StackId = k8s_core.Id, + /// Command = "pulumi up -auto-approve", + /// Everies = new[] + /// { + /// "0 7 * * 1-5", + /// }, + /// Timezone = "CET", + /// }); + /// + /// // destroy the resources of a stack on a given schedule + /// var k8s_core_destroyScheduledTask = new Spacelift.ScheduledTask("k8s-core-destroyScheduledTask", new() + /// { + /// StackId = k8s_core.Id, + /// Command = "terraform destroy -auto-approve", + /// Everies = new[] + /// { + /// "0 21 * * 1-5", + /// }, + /// Timezone = "CET", + /// }); + /// + /// // at a given timestamp (unix) + /// var k8s_core_destroyIndex_scheduledTaskScheduledTask = new Spacelift.ScheduledTask("k8s-core-destroyIndex/scheduledTaskScheduledTask", new() + /// { + /// StackId = k8s_core.Id, + /// Command = "terraform destroy -auto-approve", + /// At = 1663336895, + /// }); + /// + /// }); + /// ``` + /// + /// ## Import + /// + /// ```sh + /// $ pulumi import spacelift:index/scheduledTask:ScheduledTask ireland-kubeconfig $STACK_ID/$SCHEDULED_TASK_ID + /// ``` + /// + [SpaceliftResourceType("spacelift:index/scheduledTask:ScheduledTask")] + public partial class ScheduledTask : global::Pulumi.CustomResource + { + /// + /// Timestamp (unix timestamp) at which time the scheduled task should happen. + /// + [Output("at")] + public Output At { get; private set; } = null!; + + /// + /// Command that will be run. + /// + [Output("command")] + public Output Command { get; private set; } = null!; + + /// + /// List of cron schedule expressions based on which the scheduled task should be triggered. + /// + [Output("everies")] + public Output> Everies { get; private set; } = null!; + + /// + /// ID of the schedule + /// + [Output("scheduleId")] + public Output ScheduleId { get; private set; } = null!; + + /// + /// ID of the stack for which to set up the scheduled task + /// + [Output("stackId")] + public Output StackId { get; private set; } = null!; + + /// + /// Timezone in which the schedule is expressed. Defaults to `UTC`. + /// + [Output("timezone")] + public Output Timezone { get; private set; } = null!; + + + /// + /// Create a ScheduledTask resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public ScheduledTask(string name, ScheduledTaskArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/scheduledTask:ScheduledTask", name, args ?? new ScheduledTaskArgs(), MakeResourceOptions(options, "")) + { + } + + private ScheduledTask(string name, Input id, ScheduledTaskState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/scheduledTask:ScheduledTask", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing ScheduledTask resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static ScheduledTask Get(string name, Input id, ScheduledTaskState? state = null, CustomResourceOptions? options = null) + { + return new ScheduledTask(name, id, state, options); + } + } + + public sealed class ScheduledTaskArgs : global::Pulumi.ResourceArgs + { + /// + /// Timestamp (unix timestamp) at which time the scheduled task should happen. + /// + [Input("at")] + public Input? At { get; set; } + + /// + /// Command that will be run. + /// + [Input("command", required: true)] + public Input Command { get; set; } = null!; + + [Input("everies")] + private InputList? _everies; + + /// + /// List of cron schedule expressions based on which the scheduled task should be triggered. + /// + public InputList Everies + { + get => _everies ?? (_everies = new InputList()); + set => _everies = value; + } + + /// + /// ID of the schedule + /// + [Input("scheduleId")] + public Input? ScheduleId { get; set; } + + /// + /// ID of the stack for which to set up the scheduled task + /// + [Input("stackId", required: true)] + public Input StackId { get; set; } = null!; + + /// + /// Timezone in which the schedule is expressed. Defaults to `UTC`. + /// + [Input("timezone")] + public Input? Timezone { get; set; } + + public ScheduledTaskArgs() + { + } + public static new ScheduledTaskArgs Empty => new ScheduledTaskArgs(); + } + + public sealed class ScheduledTaskState : global::Pulumi.ResourceArgs + { + /// + /// Timestamp (unix timestamp) at which time the scheduled task should happen. + /// + [Input("at")] + public Input? At { get; set; } + + /// + /// Command that will be run. + /// + [Input("command")] + public Input? Command { get; set; } + + [Input("everies")] + private InputList? _everies; + + /// + /// List of cron schedule expressions based on which the scheduled task should be triggered. + /// + public InputList Everies + { + get => _everies ?? (_everies = new InputList()); + set => _everies = value; + } + + /// + /// ID of the schedule + /// + [Input("scheduleId")] + public Input? ScheduleId { get; set; } + + /// + /// ID of the stack for which to set up the scheduled task + /// + [Input("stackId")] + public Input? StackId { get; set; } + + /// + /// Timezone in which the schedule is expressed. Defaults to `UTC`. + /// + [Input("timezone")] + public Input? Timezone { get; set; } + + public ScheduledTaskState() + { + } + public static new ScheduledTaskState Empty => new ScheduledTaskState(); + } +} diff --git a/sdk/dotnet/Space.cs b/sdk/dotnet/Space.cs index 0cedf9a..2f236f7 100644 --- a/sdk/dotnet/Space.cs +++ b/sdk/dotnet/Space.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -57,6 +58,12 @@ public partial class Space : global::Pulumi.CustomResource [Output("inheritEntities")] public Output InheritEntities { get; private set; } = null!; + /// + /// list of labels describing a space + /// + [Output("labels")] + public Output> Labels { get; private set; } = null!; + /// /// name of the space /// @@ -128,6 +135,18 @@ public sealed class SpaceArgs : global::Pulumi.ResourceArgs [Input("inheritEntities")] public Input? InheritEntities { get; set; } + [Input("labels")] + private InputList? _labels; + + /// + /// list of labels describing a space + /// + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + /// /// name of the space /// @@ -160,6 +179,18 @@ public sealed class SpaceState : global::Pulumi.ResourceArgs [Input("inheritEntities")] public Input? InheritEntities { get; set; } + [Input("labels")] + private InputList? _labels; + + /// + /// list of labels describing a space + /// + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + /// /// name of the space /// diff --git a/sdk/dotnet/Stack.cs b/sdk/dotnet/Stack.cs index 00b33bd..4220524 100644 --- a/sdk/dotnet/Stack.cs +++ b/sdk/dotnet/Stack.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -34,7 +35,7 @@ namespace Pulumi.Spacelift /// Description = "Provisions a Kubernetes cluster", /// ProjectRoot = "cluster", /// Repository = "core-infra", - /// TerraformVersion = "0.12.6", + /// TerraformVersion = "1.3.0", /// }); /// /// // Terraform stack using Bitbucket Data Center as VCS @@ -50,10 +51,10 @@ namespace Pulumi.Spacelift /// Description = "Provisions a Kubernetes cluster", /// ProjectRoot = "cluster", /// Repository = "core-infra", - /// TerraformVersion = "0.12.6", + /// TerraformVersion = "1.3.0", /// }); /// - /// // Terraform stack using GitHub Enterprise as VCS + /// // Terraform stack using a GitHub Custom Application. See the following page for more info: https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application /// var k8s_cluster_github_enterprise = new Spacelift.Stack("k8s-cluster-github-enterprise", new() /// { /// Administrative = true, @@ -66,7 +67,7 @@ namespace Pulumi.Spacelift /// }, /// ProjectRoot = "cluster", /// Repository = "core-infra", - /// TerraformVersion = "0.12.6", + /// TerraformVersion = "1.3.0", /// }); /// /// // Terraform stack using GitLab as VCS @@ -82,10 +83,10 @@ namespace Pulumi.Spacelift /// }, /// ProjectRoot = "cluster", /// Repository = "core-infra", - /// TerraformVersion = "0.12.6", + /// TerraformVersion = "1.3.0", /// }); /// - /// // Terraform stack using github.com as VCS and enabling smart sanitization + /// // Terraform stack using github.com as VCS and enabling external state access /// var k8s_cluster = new Spacelift.Stack("k8s-cluster", new() /// { /// Administrative = true, @@ -94,8 +95,8 @@ namespace Pulumi.Spacelift /// Description = "Provisions a Kubernetes cluster", /// ProjectRoot = "cluster", /// Repository = "core-infra", - /// TerraformSmartSanitization = true, - /// TerraformVersion = "1.2.6", + /// TerraformExternalStateAccess = true, + /// TerraformVersion = "1.3.0", /// }); /// /// // CloudFormation stack using github.com as VCS @@ -122,7 +123,7 @@ namespace Pulumi.Spacelift /// Branch = "master", /// Description = "Provisions a Kubernetes cluster", /// ProjectRoot = "cluster", - /// CSHARPPULUMI = new Spacelift.Inputs.StackPulumiArgs + /// Pulumi_backend = new Spacelift.Inputs.StackPulumiArgs /// { /// LoginUrl = "s3://pulumi-state-bucket", /// StackName = "kubernetes-core-services", @@ -143,6 +144,7 @@ namespace Pulumi.Spacelift /// Description = "Shared cluster services (Datadog, Istio etc.)", /// Kubernetes = new Spacelift.Inputs.StackKubernetesArgs /// { + /// KubectlVersion = "1.26.1", /// Namespace = "core", /// }, /// ProjectRoot = "core-services", @@ -211,6 +213,12 @@ public partial class Stack : global::Pulumi.CustomResource [Output("afterPlans")] public Output> AfterPlans { get; private set; } = null!; + /// + /// List of after-run scripts + /// + [Output("afterRuns")] + public Output> AfterRuns { get; private set; } = null!; + /// /// Ansible-specific configuration. Presence means this Stack is an Ansible Stack. /// @@ -308,13 +316,13 @@ public partial class Stack : global::Pulumi.CustomResource public Output EnableLocalPreview { get; private set; } = null!; /// - /// Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + /// Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. /// [Output("githubActionDeploy")] public Output GithubActionDeploy { get; private set; } = null!; /// - /// GitHub Enterprise (self-hosted) VCS settings + /// VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) /// [Output("githubEnterprise")] public Output GithubEnterprise { get; private set; } = null!; @@ -374,7 +382,13 @@ public partial class Stack : global::Pulumi.CustomResource /// Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. /// [Output("pulumi")] - public Output CSHARPPULUMI { get; private set; } = null!; + public Output pulumi_backend { get; private set; } = null!; + + /// + /// One-way VCS integration using a raw Git repository link + /// + [Output("rawGit")] + public Output RawGit { get; private set; } = null!; /// /// Name of the repository, without the owner part @@ -398,11 +412,17 @@ public partial class Stack : global::Pulumi.CustomResource public Output Slug { get; private set; } = null!; /// - /// ID (slug) of the space the stack is in + /// ID (slug) of the space the stack is in. Defaults to `legacy`. /// [Output("spaceId")] public Output SpaceId { get; private set; } = null!; + /// + /// Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + /// + [Output("terraformExternalStateAccess")] + public Output TerraformExternalStateAccess { get; private set; } = null!; + /// /// Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state /// and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. @@ -417,6 +437,12 @@ public partial class Stack : global::Pulumi.CustomResource [Output("terraformVersion")] public Output TerraformVersion { get; private set; } = null!; + /// + /// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + /// + [Output("terraformWorkflowTool")] + public Output TerraformWorkflowTool { get; private set; } = null!; + /// /// Terraform workspace to select /// @@ -424,7 +450,13 @@ public partial class Stack : global::Pulumi.CustomResource public Output TerraformWorkspace { get; private set; } = null!; /// - /// ID of the worker pool to use + /// Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + /// + [Output("terragrunt")] + public Output Terragrunt { get; private set; } = null!; + + /// + /// ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. /// [Output("workerPoolId")] public Output WorkerPoolId { get; private set; } = null!; @@ -453,6 +485,10 @@ private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? { Version = Utilities.Version, PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + AdditionalSecretOutputs = + { + "importState", + }, }; var merged = CustomResourceOptions.Merge(defaultOptions, options); // Override the ID if one was specified for consistency with other language SDKs. @@ -542,6 +578,18 @@ public InputList AfterPlans set => _afterPlans = value; } + [Input("afterRuns")] + private InputList? _afterRuns; + + /// + /// List of after-run scripts + /// + public InputList AfterRuns + { + get => _afterRuns ?? (_afterRuns = new InputList()); + set => _afterRuns = value; + } + /// /// Ansible-specific configuration. Presence means this Stack is an Ansible Stack. /// @@ -663,13 +711,13 @@ public InputList BeforePlans public Input? EnableLocalPreview { get; set; } /// - /// Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + /// Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. /// [Input("githubActionDeploy")] public Input? GithubActionDeploy { get; set; } /// - /// GitHub Enterprise (self-hosted) VCS settings + /// VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) /// [Input("githubEnterprise")] public Input? GithubEnterprise { get; set; } @@ -680,11 +728,21 @@ public InputList BeforePlans [Input("gitlab")] public Input? Gitlab { get; set; } + [Input("importState")] + private Input? _importState; + /// /// State file to upload when creating a new stack /// - [Input("importState")] - public Input? ImportState { get; set; } + public Input? ImportState + { + get => _importState; + set + { + var emptySecret = Output.CreateSecret(0); + _importState = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// Path to the state file to upload when creating a new stack @@ -734,7 +792,13 @@ public InputList Labels /// Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. /// [Input("pulumi")] - public Input? CSHARPPULUMI { get; set; } + public Input? pulumi_backend { get; set; } + + /// + /// One-way VCS integration using a raw Git repository link + /// + [Input("rawGit")] + public Input? RawGit { get; set; } /// /// Name of the repository, without the owner part @@ -758,11 +822,17 @@ public InputList Labels public Input? Slug { get; set; } /// - /// ID (slug) of the space the stack is in + /// ID (slug) of the space the stack is in. Defaults to `legacy`. /// [Input("spaceId")] public Input? SpaceId { get; set; } + /// + /// Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + /// + [Input("terraformExternalStateAccess")] + public Input? TerraformExternalStateAccess { get; set; } + /// /// Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state /// and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. @@ -777,6 +847,12 @@ public InputList Labels [Input("terraformVersion")] public Input? TerraformVersion { get; set; } + /// + /// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + /// + [Input("terraformWorkflowTool")] + public Input? TerraformWorkflowTool { get; set; } + /// /// Terraform workspace to select /// @@ -784,7 +860,13 @@ public InputList Labels public Input? TerraformWorkspace { get; set; } /// - /// ID of the worker pool to use + /// Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + /// + [Input("terragrunt")] + public Input? Terragrunt { get; set; } + + /// + /// ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. /// [Input("workerPoolId")] public Input? WorkerPoolId { get; set; } @@ -863,6 +945,18 @@ public InputList AfterPlans set => _afterPlans = value; } + [Input("afterRuns")] + private InputList? _afterRuns; + + /// + /// List of after-run scripts + /// + public InputList AfterRuns + { + get => _afterRuns ?? (_afterRuns = new InputList()); + set => _afterRuns = value; + } + /// /// Ansible-specific configuration. Presence means this Stack is an Ansible Stack. /// @@ -990,13 +1084,13 @@ public InputList BeforePlans public Input? EnableLocalPreview { get; set; } /// - /// Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + /// Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. /// [Input("githubActionDeploy")] public Input? GithubActionDeploy { get; set; } /// - /// GitHub Enterprise (self-hosted) VCS settings + /// VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) /// [Input("githubEnterprise")] public Input? GithubEnterprise { get; set; } @@ -1007,11 +1101,21 @@ public InputList BeforePlans [Input("gitlab")] public Input? Gitlab { get; set; } + [Input("importState")] + private Input? _importState; + /// /// State file to upload when creating a new stack /// - [Input("importState")] - public Input? ImportState { get; set; } + public Input? ImportState + { + get => _importState; + set + { + var emptySecret = Output.CreateSecret(0); + _importState = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// Path to the state file to upload when creating a new stack @@ -1061,7 +1165,13 @@ public InputList Labels /// Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. /// [Input("pulumi")] - public Input? CSHARPPULUMI { get; set; } + public Input? pulumi_backend { get; set; } + + /// + /// One-way VCS integration using a raw Git repository link + /// + [Input("rawGit")] + public Input? RawGit { get; set; } /// /// Name of the repository, without the owner part @@ -1085,11 +1195,17 @@ public InputList Labels public Input? Slug { get; set; } /// - /// ID (slug) of the space the stack is in + /// ID (slug) of the space the stack is in. Defaults to `legacy`. /// [Input("spaceId")] public Input? SpaceId { get; set; } + /// + /// Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + /// + [Input("terraformExternalStateAccess")] + public Input? TerraformExternalStateAccess { get; set; } + /// /// Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state /// and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. @@ -1104,6 +1220,12 @@ public InputList Labels [Input("terraformVersion")] public Input? TerraformVersion { get; set; } + /// + /// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + /// + [Input("terraformWorkflowTool")] + public Input? TerraformWorkflowTool { get; set; } + /// /// Terraform workspace to select /// @@ -1111,7 +1233,13 @@ public InputList Labels public Input? TerraformWorkspace { get; set; } /// - /// ID of the worker pool to use + /// Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + /// + [Input("terragrunt")] + public Input? Terragrunt { get; set; } + + /// + /// ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. /// [Input("workerPoolId")] public Input? WorkerPoolId { get; set; } diff --git a/sdk/dotnet/StackActivator.cs b/sdk/dotnet/StackActivator.cs new file mode 100644 index 0000000..4918f6a --- /dev/null +++ b/sdk/dotnet/StackActivator.cs @@ -0,0 +1,139 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.StackActivator` is used to to enable/disable Spacelift Stack. + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var app = new Spacelift.Stack("app", new() + /// { + /// Branch = "master", + /// Repository = "app", + /// }); + /// + /// var test = new Spacelift.StackActivator("test", new() + /// { + /// Enabled = true, + /// StackId = app.Id, + /// }); + /// + /// }); + /// ``` + /// + [SpaceliftResourceType("spacelift:index/stackActivator:StackActivator")] + public partial class StackActivator : global::Pulumi.CustomResource + { + /// + /// Enable/disable stack + /// + [Output("enabled")] + public Output Enabled { get; private set; } = null!; + + /// + /// ID of the stack to enable/disable + /// + [Output("stackId")] + public Output StackId { get; private set; } = null!; + + + /// + /// Create a StackActivator resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public StackActivator(string name, StackActivatorArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/stackActivator:StackActivator", name, args ?? new StackActivatorArgs(), MakeResourceOptions(options, "")) + { + } + + private StackActivator(string name, Input id, StackActivatorState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/stackActivator:StackActivator", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing StackActivator resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static StackActivator Get(string name, Input id, StackActivatorState? state = null, CustomResourceOptions? options = null) + { + return new StackActivator(name, id, state, options); + } + } + + public sealed class StackActivatorArgs : global::Pulumi.ResourceArgs + { + /// + /// Enable/disable stack + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + /// + /// ID of the stack to enable/disable + /// + [Input("stackId", required: true)] + public Input StackId { get; set; } = null!; + + public StackActivatorArgs() + { + } + public static new StackActivatorArgs Empty => new StackActivatorArgs(); + } + + public sealed class StackActivatorState : global::Pulumi.ResourceArgs + { + /// + /// Enable/disable stack + /// + [Input("enabled")] + public Input? Enabled { get; set; } + + /// + /// ID of the stack to enable/disable + /// + [Input("stackId")] + public Input? StackId { get; set; } + + public StackActivatorState() + { + } + public static new StackActivatorState Empty => new StackActivatorState(); + } +} diff --git a/sdk/dotnet/StackDependency.cs b/sdk/dotnet/StackDependency.cs new file mode 100644 index 0000000..5ee2340 --- /dev/null +++ b/sdk/dotnet/StackDependency.cs @@ -0,0 +1,145 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.StackDependency` represents a Spacelift **stack dependency** - a dependency between two stacks. When one stack depends on another, the tracked runs of the stack will not start until the dependent stack is successfully finished. Additionally, changes to the dependency will trigger the dependent. + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var infra = new Spacelift.Stack("infra", new() + /// { + /// Branch = "master", + /// Repository = "core-infra", + /// }); + /// + /// var app = new Spacelift.Stack("app", new() + /// { + /// Branch = "master", + /// Repository = "app", + /// }); + /// + /// var test = new Spacelift.StackDependency("test", new() + /// { + /// StackId = app.Id, + /// DependsOnStackId = infra.Id, + /// }); + /// + /// }); + /// ``` + /// + [SpaceliftResourceType("spacelift:index/stackDependency:StackDependency")] + public partial class StackDependency : global::Pulumi.CustomResource + { + /// + /// immutable ID (slug) of stack to depend on. + /// + [Output("dependsOnStackId")] + public Output DependsOnStackId { get; private set; } = null!; + + /// + /// immutable ID (slug) of stack which has a dependency. + /// + [Output("stackId")] + public Output StackId { get; private set; } = null!; + + + /// + /// Create a StackDependency resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public StackDependency(string name, StackDependencyArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/stackDependency:StackDependency", name, args ?? new StackDependencyArgs(), MakeResourceOptions(options, "")) + { + } + + private StackDependency(string name, Input id, StackDependencyState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/stackDependency:StackDependency", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing StackDependency resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static StackDependency Get(string name, Input id, StackDependencyState? state = null, CustomResourceOptions? options = null) + { + return new StackDependency(name, id, state, options); + } + } + + public sealed class StackDependencyArgs : global::Pulumi.ResourceArgs + { + /// + /// immutable ID (slug) of stack to depend on. + /// + [Input("dependsOnStackId", required: true)] + public Input DependsOnStackId { get; set; } = null!; + + /// + /// immutable ID (slug) of stack which has a dependency. + /// + [Input("stackId", required: true)] + public Input StackId { get; set; } = null!; + + public StackDependencyArgs() + { + } + public static new StackDependencyArgs Empty => new StackDependencyArgs(); + } + + public sealed class StackDependencyState : global::Pulumi.ResourceArgs + { + /// + /// immutable ID (slug) of stack to depend on. + /// + [Input("dependsOnStackId")] + public Input? DependsOnStackId { get; set; } + + /// + /// immutable ID (slug) of stack which has a dependency. + /// + [Input("stackId")] + public Input? StackId { get; set; } + + public StackDependencyState() + { + } + public static new StackDependencyState Empty => new StackDependencyState(); + } +} diff --git a/sdk/dotnet/StackDependencyReference.cs b/sdk/dotnet/StackDependencyReference.cs new file mode 100644 index 0000000..90522c4 --- /dev/null +++ b/sdk/dotnet/StackDependencyReference.cs @@ -0,0 +1,170 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.StackDependencyReference` represents a Spacelift **stack dependency reference** - a reference matches a stack's output to another stack's input. It is similar to an environment variable (`spacelift.EnvironmentVariable`), except that value is provided by another stack's output. + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var infra = new Spacelift.Stack("infra", new() + /// { + /// Branch = "master", + /// Repository = "core-infra", + /// }); + /// + /// var app = new Spacelift.Stack("app", new() + /// { + /// Branch = "master", + /// Repository = "app", + /// }); + /// + /// var testStackDependency = new Spacelift.StackDependency("testStackDependency", new() + /// { + /// StackId = app.Id, + /// DependsOnStackId = infra.Id, + /// }); + /// + /// var testStackDependencyReference = new Spacelift.StackDependencyReference("testStackDependencyReference", new() + /// { + /// StackDependencyId = testStackDependency.Id, + /// OutputName = "DB_CONNECTION_STRING", + /// InputName = "APP_DB_URL", + /// }); + /// + /// }); + /// ``` + /// + [SpaceliftResourceType("spacelift:index/stackDependencyReference:StackDependencyReference")] + public partial class StackDependencyReference : global::Pulumi.CustomResource + { + /// + /// Name of the input of the stack dependency reference + /// + [Output("inputName")] + public Output InputName { get; private set; } = null!; + + /// + /// Name of the output of stack to depend on + /// + [Output("outputName")] + public Output OutputName { get; private set; } = null!; + + /// + /// Immutable ID of stack dependency + /// + [Output("stackDependencyId")] + public Output StackDependencyId { get; private set; } = null!; + + + /// + /// Create a StackDependencyReference resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public StackDependencyReference(string name, StackDependencyReferenceArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/stackDependencyReference:StackDependencyReference", name, args ?? new StackDependencyReferenceArgs(), MakeResourceOptions(options, "")) + { + } + + private StackDependencyReference(string name, Input id, StackDependencyReferenceState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/stackDependencyReference:StackDependencyReference", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing StackDependencyReference resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static StackDependencyReference Get(string name, Input id, StackDependencyReferenceState? state = null, CustomResourceOptions? options = null) + { + return new StackDependencyReference(name, id, state, options); + } + } + + public sealed class StackDependencyReferenceArgs : global::Pulumi.ResourceArgs + { + /// + /// Name of the input of the stack dependency reference + /// + [Input("inputName", required: true)] + public Input InputName { get; set; } = null!; + + /// + /// Name of the output of stack to depend on + /// + [Input("outputName", required: true)] + public Input OutputName { get; set; } = null!; + + /// + /// Immutable ID of stack dependency + /// + [Input("stackDependencyId", required: true)] + public Input StackDependencyId { get; set; } = null!; + + public StackDependencyReferenceArgs() + { + } + public static new StackDependencyReferenceArgs Empty => new StackDependencyReferenceArgs(); + } + + public sealed class StackDependencyReferenceState : global::Pulumi.ResourceArgs + { + /// + /// Name of the input of the stack dependency reference + /// + [Input("inputName")] + public Input? InputName { get; set; } + + /// + /// Name of the output of stack to depend on + /// + [Input("outputName")] + public Input? OutputName { get; set; } + + /// + /// Immutable ID of stack dependency + /// + [Input("stackDependencyId")] + public Input? StackDependencyId { get; set; } + + public StackDependencyReferenceState() + { + } + public static new StackDependencyReferenceState Empty => new StackDependencyReferenceState(); + } +} diff --git a/sdk/dotnet/StackDestructor.cs b/sdk/dotnet/StackDestructor.cs index 5346a58..d8d22b6 100644 --- a/sdk/dotnet/StackDestructor.cs +++ b/sdk/dotnet/StackDestructor.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// diff --git a/sdk/dotnet/StackGcpServiceAccount.cs b/sdk/dotnet/StackGcpServiceAccount.cs index 1b428ab..f9c505a 100644 --- a/sdk/dotnet/StackGcpServiceAccount.cs +++ b/sdk/dotnet/StackGcpServiceAccount.cs @@ -14,8 +14,9 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; - /// using Gcp = Pulumi.Gcp; + /// using Google = Pulumi.Google; /// using Spacelift = Pulumi.Spacelift; /// /// return await Deployment.RunAsync(() => @@ -37,17 +38,18 @@ namespace Pulumi.Spacelift /// }, /// }); /// - /// var k8s_coreProject = new Gcp.Organizations.Project("k8s-coreProject", new() + /// var k8s_coregoogle_project = new Google.Index.Google_project("k8s-coregoogle_project", new() /// { + /// Name = "Kubernetes code", /// ProjectId = "unicorn-k8s-core", /// OrgId = @var.Gcp_organization_id, /// }); /// - /// var k8s_coreIAMMember = new Gcp.Projects.IAMMember("k8s-coreIAMMember", new() + /// var k8s_coregoogle_project_iam_member = new Google.Index.Google_project_iam_member("k8s-coregoogle_project_iam_member", new() /// { - /// Project = k8s_coreProject.Id, + /// Project = k8s_coregoogle_project.Id, /// Role = "roles/owner", - /// Member = k8s_coreStackGcpServiceAccount.ServiceAccountEmail.Apply(serviceAccountEmail => $"serviceAccount:{serviceAccountEmail}"), + /// Member = $"serviceAccount:{k8s_coreStackGcpServiceAccount.ServiceAccountEmail}", /// }); /// /// }); diff --git a/sdk/dotnet/TerraformProvider.cs b/sdk/dotnet/TerraformProvider.cs new file mode 100644 index 0000000..42b93e9 --- /dev/null +++ b/sdk/dotnet/TerraformProvider.cs @@ -0,0 +1,192 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Spacelift = Pulumi.Spacelift; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var datadog = new Spacelift.TerraformProvider("datadog", new() + /// { + /// Description = "Our fork of the Datadog provider", + /// Labels = new[] + /// { + /// "fork", + /// }, + /// Public = false, + /// SpaceId = "root", + /// Type = "datadog", + /// }); + /// + /// }); + /// ``` + /// + [SpaceliftResourceType("spacelift:index/terraformProvider:TerraformProvider")] + public partial class TerraformProvider : global::Pulumi.CustomResource + { + /// + /// Free-form description for human users, supports Markdown + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + [Output("labels")] + public Output> Labels { get; private set; } = null!; + + /// + /// Whether the provider is public or not, defaults to false (private) + /// + [Output("public")] + public Output Public { get; private set; } = null!; + + /// + /// ID (slug) of the space the provider is in + /// + [Output("spaceId")] + public Output SpaceId { get; private set; } = null!; + + /// + /// Type of the provider - should be unique in one account + /// + [Output("type")] + public Output Type { get; private set; } = null!; + + + /// + /// Create a TerraformProvider resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public TerraformProvider(string name, TerraformProviderArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/terraformProvider:TerraformProvider", name, args ?? new TerraformProviderArgs(), MakeResourceOptions(options, "")) + { + } + + private TerraformProvider(string name, Input id, TerraformProviderState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/terraformProvider:TerraformProvider", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing TerraformProvider resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static TerraformProvider Get(string name, Input id, TerraformProviderState? state = null, CustomResourceOptions? options = null) + { + return new TerraformProvider(name, id, state, options); + } + } + + public sealed class TerraformProviderArgs : global::Pulumi.ResourceArgs + { + /// + /// Free-form description for human users, supports Markdown + /// + [Input("description")] + public Input? Description { get; set; } + + [Input("labels")] + private InputList? _labels; + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + + /// + /// Whether the provider is public or not, defaults to false (private) + /// + [Input("public")] + public Input? Public { get; set; } + + /// + /// ID (slug) of the space the provider is in + /// + [Input("spaceId", required: true)] + public Input SpaceId { get; set; } = null!; + + /// + /// Type of the provider - should be unique in one account + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public TerraformProviderArgs() + { + } + public static new TerraformProviderArgs Empty => new TerraformProviderArgs(); + } + + public sealed class TerraformProviderState : global::Pulumi.ResourceArgs + { + /// + /// Free-form description for human users, supports Markdown + /// + [Input("description")] + public Input? Description { get; set; } + + [Input("labels")] + private InputList? _labels; + public InputList Labels + { + get => _labels ?? (_labels = new InputList()); + set => _labels = value; + } + + /// + /// Whether the provider is public or not, defaults to false (private) + /// + [Input("public")] + public Input? Public { get; set; } + + /// + /// ID (slug) of the space the provider is in + /// + [Input("spaceId")] + public Input? SpaceId { get; set; } + + /// + /// Type of the provider - should be unique in one account + /// + [Input("type")] + public Input? Type { get; set; } + + public TerraformProviderState() + { + } + public static new TerraformProviderState Empty => new TerraformProviderState(); + } +} diff --git a/sdk/dotnet/User.cs b/sdk/dotnet/User.cs new file mode 100644 index 0000000..99844ed --- /dev/null +++ b/sdk/dotnet/User.cs @@ -0,0 +1,133 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.User` represents a mapping between a Spacelift user (managed using an Identity Provider) and a Policy. A Policy defines what access rights the user has to a given Space. + /// + [SpaceliftResourceType("spacelift:index/user:User")] + public partial class User : global::Pulumi.CustomResource + { + /// + /// Email of the user. Used for sending an invitation. + /// + [Output("invitationEmail")] + public Output InvitationEmail { get; private set; } = null!; + + [Output("policies")] + public Output> Policies { get; private set; } = null!; + + /// + /// Username of the user + /// + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a User resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public User(string name, UserArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/user:User", name, args ?? new UserArgs(), MakeResourceOptions(options, "")) + { + } + + private User(string name, Input id, UserState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/user:User", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing User resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static User Get(string name, Input id, UserState? state = null, CustomResourceOptions? options = null) + { + return new User(name, id, state, options); + } + } + + public sealed class UserArgs : global::Pulumi.ResourceArgs + { + /// + /// Email of the user. Used for sending an invitation. + /// + [Input("invitationEmail", required: true)] + public Input InvitationEmail { get; set; } = null!; + + [Input("policies", required: true)] + private InputList? _policies; + public InputList Policies + { + get => _policies ?? (_policies = new InputList()); + set => _policies = value; + } + + /// + /// Username of the user + /// + [Input("username", required: true)] + public Input Username { get; set; } = null!; + + public UserArgs() + { + } + public static new UserArgs Empty => new UserArgs(); + } + + public sealed class UserState : global::Pulumi.ResourceArgs + { + /// + /// Email of the user. Used for sending an invitation. + /// + [Input("invitationEmail")] + public Input? InvitationEmail { get; set; } + + [Input("policies")] + private InputList? _policies; + public InputList Policies + { + get => _policies ?? (_policies = new InputList()); + set => _policies = value; + } + + /// + /// Username of the user + /// + [Input("username")] + public Input? Username { get; set; } + + public UserState() + { + } + public static new UserState Empty => new UserState(); + } +} diff --git a/sdk/dotnet/VcsAgentPool.cs b/sdk/dotnet/VcsAgentPool.cs index d654622..f5954c0 100644 --- a/sdk/dotnet/VcsAgentPool.cs +++ b/sdk/dotnet/VcsAgentPool.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -80,6 +81,10 @@ private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? { Version = Utilities.Version, PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + AdditionalSecretOutputs = + { + "config", + }, }; var merged = CustomResourceOptions.Merge(defaultOptions, options); // Override the ID if one was specified for consistency with other language SDKs. @@ -123,11 +128,21 @@ public VcsAgentPoolArgs() public sealed class VcsAgentPoolState : global::Pulumi.ResourceArgs { + [Input("config")] + private Input? _config; + /// /// VCS agent pool configuration, encoded using base64 /// - [Input("config")] - public Input? Config { get; set; } + public Input? Config + { + get => _config; + set + { + var emptySecret = Output.CreateSecret(0); + _config = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// Free-form VCS agent pool description for users diff --git a/sdk/dotnet/Version.cs b/sdk/dotnet/Version.cs new file mode 100644 index 0000000..8c86b28 --- /dev/null +++ b/sdk/dotnet/Version.cs @@ -0,0 +1,162 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Spacelift +{ + /// + /// `spacelift.Version` allows to programmatically trigger a version creation in response to arbitrary changes in the keepers section. + /// + [SpaceliftResourceType("spacelift:index/version:Version")] + public partial class Version : global::Pulumi.CustomResource + { + /// + /// The commit SHA for which to trigger a version. + /// + [Output("commitSha")] + public Output CommitSha { get; private set; } = null!; + + /// + /// Arbitrary map of values that, when changed, will trigger recreation of the resource. + /// + [Output("keepers")] + public Output?> Keepers { get; private set; } = null!; + + /// + /// ID of the module on which the version creation is to be triggered. + /// + [Output("moduleId")] + public Output ModuleId { get; private set; } = null!; + + /// + /// A semantic version number to set for the triggered version, example: 0.11.2 + /// + [Output("versionNumber")] + public Output VersionNumber { get; private set; } = null!; + + + /// + /// Create a Version resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public Version(string name, VersionArgs args, CustomResourceOptions? options = null) + : base("spacelift:index/version:Version", name, args ?? new VersionArgs(), MakeResourceOptions(options, "")) + { + } + + private Version(string name, Input id, VersionState? state = null, CustomResourceOptions? options = null) + : base("spacelift:index/version:Version", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing Version resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static Version Get(string name, Input id, VersionState? state = null, CustomResourceOptions? options = null) + { + return new Version(name, id, state, options); + } + } + + public sealed class VersionArgs : global::Pulumi.ResourceArgs + { + /// + /// The commit SHA for which to trigger a version. + /// + [Input("commitSha")] + public Input? CommitSha { get; set; } + + [Input("keepers")] + private InputMap? _keepers; + + /// + /// Arbitrary map of values that, when changed, will trigger recreation of the resource. + /// + public InputMap Keepers + { + get => _keepers ?? (_keepers = new InputMap()); + set => _keepers = value; + } + + /// + /// ID of the module on which the version creation is to be triggered. + /// + [Input("moduleId", required: true)] + public Input ModuleId { get; set; } = null!; + + /// + /// A semantic version number to set for the triggered version, example: 0.11.2 + /// + [Input("versionNumber")] + public Input? VersionNumber { get; set; } + + public VersionArgs() + { + } + public static new VersionArgs Empty => new VersionArgs(); + } + + public sealed class VersionState : global::Pulumi.ResourceArgs + { + /// + /// The commit SHA for which to trigger a version. + /// + [Input("commitSha")] + public Input? CommitSha { get; set; } + + [Input("keepers")] + private InputMap? _keepers; + + /// + /// Arbitrary map of values that, when changed, will trigger recreation of the resource. + /// + public InputMap Keepers + { + get => _keepers ?? (_keepers = new InputMap()); + set => _keepers = value; + } + + /// + /// ID of the module on which the version creation is to be triggered. + /// + [Input("moduleId")] + public Input? ModuleId { get; set; } + + /// + /// A semantic version number to set for the triggered version, example: 0.11.2 + /// + [Input("versionNumber")] + public Input? VersionNumber { get; set; } + + public VersionState() + { + } + public static new VersionState Empty => new VersionState(); + } +} diff --git a/sdk/dotnet/Webhook.cs b/sdk/dotnet/Webhook.cs index abee2b1..0d6f6ee 100644 --- a/sdk/dotnet/Webhook.cs +++ b/sdk/dotnet/Webhook.cs @@ -16,6 +16,7 @@ namespace Pulumi.Spacelift /// /// ```csharp /// using System.Collections.Generic; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// @@ -93,6 +94,10 @@ private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? { Version = Utilities.Version, PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + AdditionalSecretOutputs = + { + "secret", + }, }; var merged = CustomResourceOptions.Merge(defaultOptions, options); // Override the ID if one was specified for consistency with other language SDKs. @@ -134,11 +139,21 @@ public sealed class WebhookArgs : global::Pulumi.ResourceArgs [Input("moduleId")] public Input? ModuleId { get; set; } + [Input("secret")] + private Input? _secret; + /// /// secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. /// - [Input("secret")] - public Input? Secret { get; set; } + public Input? Secret + { + get => _secret; + set + { + var emptySecret = Output.CreateSecret(0); + _secret = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// ID of the stack which triggers the webhooks @@ -172,11 +187,21 @@ public sealed class WebhookState : global::Pulumi.ResourceArgs [Input("moduleId")] public Input? ModuleId { get; set; } + [Input("secret")] + private Input? _secret; + /// /// secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. /// - [Input("secret")] - public Input? Secret { get; set; } + public Input? Secret + { + get => _secret; + set + { + var emptySecret = Output.CreateSecret(0); + _secret = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// ID of the stack which triggers the webhooks diff --git a/sdk/dotnet/WorkerPool.cs b/sdk/dotnet/WorkerPool.cs index ef6c60a..4af71f6 100644 --- a/sdk/dotnet/WorkerPool.cs +++ b/sdk/dotnet/WorkerPool.cs @@ -18,11 +18,12 @@ namespace Pulumi.Spacelift /// using System; /// using System.Collections.Generic; /// using System.IO; + /// using System.Linq; /// using Pulumi; /// using Spacelift = Pulumi.Spacelift; /// /// private static string ReadFileBase64(string path) { - /// return Convert.ToBase64String(Encoding.UTF8.GetBytes(File.ReadAllText(path))) + /// return Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(File.ReadAllText(path))); /// } /// /// return await Deployment.RunAsync(() => @@ -108,6 +109,12 @@ private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? { Version = Utilities.Version, PluginDownloadURL = "https://downloads.spacelift.io/pulumi-plugins", + AdditionalSecretOutputs = + { + "config", + "csr", + "privateKey", + }, }; var merged = CustomResourceOptions.Merge(defaultOptions, options); // Override the ID if one was specified for consistency with other language SDKs. @@ -131,11 +138,21 @@ public static WorkerPool Get(string name, Input id, WorkerPoolState? sta public sealed class WorkerPoolArgs : global::Pulumi.ResourceArgs { + [Input("csr")] + private Input? _csr; + /// /// certificate signing request in base64 /// - [Input("csr")] - public Input? Csr { get; set; } + public Input? Csr + { + get => _csr; + set + { + var emptySecret = Output.CreateSecret(0); + _csr = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// description of the worker pool @@ -171,17 +188,37 @@ public WorkerPoolArgs() public sealed class WorkerPoolState : global::Pulumi.ResourceArgs { + [Input("config")] + private Input? _config; + /// /// credentials necessary to connect WorkerPool's workers to the control plane /// - [Input("config")] - public Input? Config { get; set; } + public Input? Config + { + get => _config; + set + { + var emptySecret = Output.CreateSecret(0); + _config = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("csr")] + private Input? _csr; /// /// certificate signing request in base64 /// - [Input("csr")] - public Input? Csr { get; set; } + public Input? Csr + { + get => _csr; + set + { + var emptySecret = Output.CreateSecret(0); + _csr = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// description of the worker pool @@ -203,11 +240,21 @@ public InputList Labels [Input("name")] public Input? Name { get; set; } + [Input("privateKey")] + private Input? _privateKey; + /// /// private key in base64 /// - [Input("privateKey")] - public Input? PrivateKey { get; set; } + public Input? PrivateKey + { + get => _privateKey; + set + { + var emptySecret = Output.CreateSecret(0); + _privateKey = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } /// /// ID (slug) of the space the worker pool is in diff --git a/sdk/dotnet/logo.png b/sdk/dotnet/logo.png index 181f421..1bca11d 100644 Binary files a/sdk/dotnet/logo.png and b/sdk/dotnet/logo.png differ diff --git a/sdk/go/spacelift/awsIntegration.go b/sdk/go/spacelift/awsIntegration.go index 14d6e84..d285c91 100644 --- a/sdk/go/spacelift/awsIntegration.go +++ b/sdk/go/spacelift/awsIntegration.go @@ -7,13 +7,15 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. // -// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-$suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. +// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@$suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. // // ## Import // @@ -51,7 +53,7 @@ func NewAwsIntegration(ctx *pulumi.Context, if args.RoleArn == nil { return nil, errors.New("invalid value for required argument 'RoleArn'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource AwsIntegration err := ctx.RegisterResource("spacelift:index/awsIntegration:AwsIntegration", name, args, &resource, opts...) if err != nil { @@ -169,6 +171,12 @@ func (i *AwsIntegration) ToAwsIntegrationOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(AwsIntegrationOutput) } +func (i *AwsIntegration) ToOutput(ctx context.Context) pulumix.Output[*AwsIntegration] { + return pulumix.Output[*AwsIntegration]{ + OutputState: i.ToAwsIntegrationOutputWithContext(ctx).OutputState, + } +} + // AwsIntegrationArrayInput is an input type that accepts AwsIntegrationArray and AwsIntegrationArrayOutput values. // You can construct a concrete instance of `AwsIntegrationArrayInput` via: // @@ -194,6 +202,12 @@ func (i AwsIntegrationArray) ToAwsIntegrationArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(AwsIntegrationArrayOutput) } +func (i AwsIntegrationArray) ToOutput(ctx context.Context) pulumix.Output[[]*AwsIntegration] { + return pulumix.Output[[]*AwsIntegration]{ + OutputState: i.ToAwsIntegrationArrayOutputWithContext(ctx).OutputState, + } +} + // AwsIntegrationMapInput is an input type that accepts AwsIntegrationMap and AwsIntegrationMapOutput values. // You can construct a concrete instance of `AwsIntegrationMapInput` via: // @@ -219,6 +233,12 @@ func (i AwsIntegrationMap) ToAwsIntegrationMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(AwsIntegrationMapOutput) } +func (i AwsIntegrationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AwsIntegration] { + return pulumix.Output[map[string]*AwsIntegration]{ + OutputState: i.ToAwsIntegrationMapOutputWithContext(ctx).OutputState, + } +} + type AwsIntegrationOutput struct{ *pulumi.OutputState } func (AwsIntegrationOutput) ElementType() reflect.Type { @@ -233,6 +253,12 @@ func (o AwsIntegrationOutput) ToAwsIntegrationOutputWithContext(ctx context.Cont return o } +func (o AwsIntegrationOutput) ToOutput(ctx context.Context) pulumix.Output[*AwsIntegration] { + return pulumix.Output[*AwsIntegration]{ + OutputState: o.OutputState, + } +} + // Duration in seconds for which the assumed role credentials should be valid. Defaults to `900`. func (o AwsIntegrationOutput) DurationSeconds() pulumi.IntPtrOutput { return o.ApplyT(func(v *AwsIntegration) pulumi.IntPtrOutput { return v.DurationSeconds }).(pulumi.IntPtrOutput) @@ -282,6 +308,12 @@ func (o AwsIntegrationArrayOutput) ToAwsIntegrationArrayOutputWithContext(ctx co return o } +func (o AwsIntegrationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*AwsIntegration] { + return pulumix.Output[[]*AwsIntegration]{ + OutputState: o.OutputState, + } +} + func (o AwsIntegrationArrayOutput) Index(i pulumi.IntInput) AwsIntegrationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AwsIntegration { return vs[0].([]*AwsIntegration)[vs[1].(int)] @@ -302,6 +334,12 @@ func (o AwsIntegrationMapOutput) ToAwsIntegrationMapOutputWithContext(ctx contex return o } +func (o AwsIntegrationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*AwsIntegration] { + return pulumix.Output[map[string]*AwsIntegration]{ + OutputState: o.OutputState, + } +} + func (o AwsIntegrationMapOutput) MapIndex(k pulumi.StringInput) AwsIntegrationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AwsIntegration { return vs[0].(map[string]*AwsIntegration)[vs[1].(string)] diff --git a/sdk/go/spacelift/awsIntegrationAttachment.go b/sdk/go/spacelift/awsIntegrationAttachment.go index 032bc5e..045e05c 100644 --- a/sdk/go/spacelift/awsIntegrationAttachment.go +++ b/sdk/go/spacelift/awsIntegrationAttachment.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AwsIntegrationAttachment` represents the attachment between a reusable AWS integration and a single stack or module. @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -89,7 +91,7 @@ func NewAwsIntegrationAttachment(ctx *pulumi.Context, if args.IntegrationId == nil { return nil, errors.New("invalid value for required argument 'IntegrationId'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource AwsIntegrationAttachment err := ctx.RegisterResource("spacelift:index/awsIntegrationAttachment:AwsIntegrationAttachment", name, args, &resource, opts...) if err != nil { @@ -195,6 +197,12 @@ func (i *AwsIntegrationAttachment) ToAwsIntegrationAttachmentOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(AwsIntegrationAttachmentOutput) } +func (i *AwsIntegrationAttachment) ToOutput(ctx context.Context) pulumix.Output[*AwsIntegrationAttachment] { + return pulumix.Output[*AwsIntegrationAttachment]{ + OutputState: i.ToAwsIntegrationAttachmentOutputWithContext(ctx).OutputState, + } +} + // AwsIntegrationAttachmentArrayInput is an input type that accepts AwsIntegrationAttachmentArray and AwsIntegrationAttachmentArrayOutput values. // You can construct a concrete instance of `AwsIntegrationAttachmentArrayInput` via: // @@ -220,6 +228,12 @@ func (i AwsIntegrationAttachmentArray) ToAwsIntegrationAttachmentArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(AwsIntegrationAttachmentArrayOutput) } +func (i AwsIntegrationAttachmentArray) ToOutput(ctx context.Context) pulumix.Output[[]*AwsIntegrationAttachment] { + return pulumix.Output[[]*AwsIntegrationAttachment]{ + OutputState: i.ToAwsIntegrationAttachmentArrayOutputWithContext(ctx).OutputState, + } +} + // AwsIntegrationAttachmentMapInput is an input type that accepts AwsIntegrationAttachmentMap and AwsIntegrationAttachmentMapOutput values. // You can construct a concrete instance of `AwsIntegrationAttachmentMapInput` via: // @@ -245,6 +259,12 @@ func (i AwsIntegrationAttachmentMap) ToAwsIntegrationAttachmentMapOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(AwsIntegrationAttachmentMapOutput) } +func (i AwsIntegrationAttachmentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AwsIntegrationAttachment] { + return pulumix.Output[map[string]*AwsIntegrationAttachment]{ + OutputState: i.ToAwsIntegrationAttachmentMapOutputWithContext(ctx).OutputState, + } +} + type AwsIntegrationAttachmentOutput struct{ *pulumi.OutputState } func (AwsIntegrationAttachmentOutput) ElementType() reflect.Type { @@ -259,6 +279,12 @@ func (o AwsIntegrationAttachmentOutput) ToAwsIntegrationAttachmentOutputWithCont return o } +func (o AwsIntegrationAttachmentOutput) ToOutput(ctx context.Context) pulumix.Output[*AwsIntegrationAttachment] { + return pulumix.Output[*AwsIntegrationAttachment]{ + OutputState: o.OutputState, + } +} + // Internal ID of the attachment entity func (o AwsIntegrationAttachmentOutput) AttachmentId() pulumi.StringOutput { return o.ApplyT(func(v *AwsIntegrationAttachment) pulumi.StringOutput { return v.AttachmentId }).(pulumi.StringOutput) @@ -303,6 +329,12 @@ func (o AwsIntegrationAttachmentArrayOutput) ToAwsIntegrationAttachmentArrayOutp return o } +func (o AwsIntegrationAttachmentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*AwsIntegrationAttachment] { + return pulumix.Output[[]*AwsIntegrationAttachment]{ + OutputState: o.OutputState, + } +} + func (o AwsIntegrationAttachmentArrayOutput) Index(i pulumi.IntInput) AwsIntegrationAttachmentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AwsIntegrationAttachment { return vs[0].([]*AwsIntegrationAttachment)[vs[1].(int)] @@ -323,6 +355,12 @@ func (o AwsIntegrationAttachmentMapOutput) ToAwsIntegrationAttachmentMapOutputWi return o } +func (o AwsIntegrationAttachmentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*AwsIntegrationAttachment] { + return pulumix.Output[map[string]*AwsIntegrationAttachment]{ + OutputState: o.OutputState, + } +} + func (o AwsIntegrationAttachmentMapOutput) MapIndex(k pulumi.StringInput) AwsIntegrationAttachmentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AwsIntegrationAttachment { return vs[0].(map[string]*AwsIntegrationAttachment)[vs[1].(string)] diff --git a/sdk/go/spacelift/awsRole.go b/sdk/go/spacelift/awsRole.go index fddf2f1..5c83edb 100644 --- a/sdk/go/spacelift/awsRole.go +++ b/sdk/go/spacelift/awsRole.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // **NOTE:** while this resource continues to work, we have replaced it with the `AwsIntegration` resource. The new resource allows integrations to be shared by multiple stacks/modules and also supports separate read vs write roles. Please use the `AwsIntegration` resource instead. @@ -59,7 +61,7 @@ func NewAwsRole(ctx *pulumi.Context, if args.RoleArn == nil { return nil, errors.New("invalid value for required argument 'RoleArn'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource AwsRole err := ctx.RegisterResource("spacelift:index/awsRole:AwsRole", name, args, &resource, opts...) if err != nil { @@ -169,6 +171,12 @@ func (i *AwsRole) ToAwsRoleOutputWithContext(ctx context.Context) AwsRoleOutput return pulumi.ToOutputWithContext(ctx, i).(AwsRoleOutput) } +func (i *AwsRole) ToOutput(ctx context.Context) pulumix.Output[*AwsRole] { + return pulumix.Output[*AwsRole]{ + OutputState: i.ToAwsRoleOutputWithContext(ctx).OutputState, + } +} + // AwsRoleArrayInput is an input type that accepts AwsRoleArray and AwsRoleArrayOutput values. // You can construct a concrete instance of `AwsRoleArrayInput` via: // @@ -194,6 +202,12 @@ func (i AwsRoleArray) ToAwsRoleArrayOutputWithContext(ctx context.Context) AwsRo return pulumi.ToOutputWithContext(ctx, i).(AwsRoleArrayOutput) } +func (i AwsRoleArray) ToOutput(ctx context.Context) pulumix.Output[[]*AwsRole] { + return pulumix.Output[[]*AwsRole]{ + OutputState: i.ToAwsRoleArrayOutputWithContext(ctx).OutputState, + } +} + // AwsRoleMapInput is an input type that accepts AwsRoleMap and AwsRoleMapOutput values. // You can construct a concrete instance of `AwsRoleMapInput` via: // @@ -219,6 +233,12 @@ func (i AwsRoleMap) ToAwsRoleMapOutputWithContext(ctx context.Context) AwsRoleMa return pulumi.ToOutputWithContext(ctx, i).(AwsRoleMapOutput) } +func (i AwsRoleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AwsRole] { + return pulumix.Output[map[string]*AwsRole]{ + OutputState: i.ToAwsRoleMapOutputWithContext(ctx).OutputState, + } +} + type AwsRoleOutput struct{ *pulumi.OutputState } func (AwsRoleOutput) ElementType() reflect.Type { @@ -233,6 +253,12 @@ func (o AwsRoleOutput) ToAwsRoleOutputWithContext(ctx context.Context) AwsRoleOu return o } +func (o AwsRoleOutput) ToOutput(ctx context.Context) pulumix.Output[*AwsRole] { + return pulumix.Output[*AwsRole]{ + OutputState: o.OutputState, + } +} + // AWS IAM role session duration in seconds func (o AwsRoleOutput) DurationSeconds() pulumi.IntOutput { return o.ApplyT(func(v *AwsRole) pulumi.IntOutput { return v.DurationSeconds }).(pulumi.IntOutput) @@ -277,6 +303,12 @@ func (o AwsRoleArrayOutput) ToAwsRoleArrayOutputWithContext(ctx context.Context) return o } +func (o AwsRoleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*AwsRole] { + return pulumix.Output[[]*AwsRole]{ + OutputState: o.OutputState, + } +} + func (o AwsRoleArrayOutput) Index(i pulumi.IntInput) AwsRoleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AwsRole { return vs[0].([]*AwsRole)[vs[1].(int)] @@ -297,6 +329,12 @@ func (o AwsRoleMapOutput) ToAwsRoleMapOutputWithContext(ctx context.Context) Aws return o } +func (o AwsRoleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*AwsRole] { + return pulumix.Output[map[string]*AwsRole]{ + OutputState: o.OutputState, + } +} + func (o AwsRoleMapOutput) MapIndex(k pulumi.StringInput) AwsRoleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AwsRole { return vs[0].(map[string]*AwsRole)[vs[1].(string)] diff --git a/sdk/go/spacelift/azureIntegration.go b/sdk/go/spacelift/azureIntegration.go index 6a79599..ba0d19e 100644 --- a/sdk/go/spacelift/azureIntegration.go +++ b/sdk/go/spacelift/azureIntegration.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AzureIntegration` represents an integration with an Azure AD tenant. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. Note that you will need to provide admin consent manually for the integration to work @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -84,7 +86,7 @@ func NewAzureIntegration(ctx *pulumi.Context, if args.TenantId == nil { return nil, errors.New("invalid value for required argument 'TenantId'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource AzureIntegration err := ctx.RegisterResource("spacelift:index/azureIntegration:AzureIntegration", name, args, &resource, opts...) if err != nil { @@ -202,6 +204,12 @@ func (i *AzureIntegration) ToAzureIntegrationOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(AzureIntegrationOutput) } +func (i *AzureIntegration) ToOutput(ctx context.Context) pulumix.Output[*AzureIntegration] { + return pulumix.Output[*AzureIntegration]{ + OutputState: i.ToAzureIntegrationOutputWithContext(ctx).OutputState, + } +} + // AzureIntegrationArrayInput is an input type that accepts AzureIntegrationArray and AzureIntegrationArrayOutput values. // You can construct a concrete instance of `AzureIntegrationArrayInput` via: // @@ -227,6 +235,12 @@ func (i AzureIntegrationArray) ToAzureIntegrationArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(AzureIntegrationArrayOutput) } +func (i AzureIntegrationArray) ToOutput(ctx context.Context) pulumix.Output[[]*AzureIntegration] { + return pulumix.Output[[]*AzureIntegration]{ + OutputState: i.ToAzureIntegrationArrayOutputWithContext(ctx).OutputState, + } +} + // AzureIntegrationMapInput is an input type that accepts AzureIntegrationMap and AzureIntegrationMapOutput values. // You can construct a concrete instance of `AzureIntegrationMapInput` via: // @@ -252,6 +266,12 @@ func (i AzureIntegrationMap) ToAzureIntegrationMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(AzureIntegrationMapOutput) } +func (i AzureIntegrationMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AzureIntegration] { + return pulumix.Output[map[string]*AzureIntegration]{ + OutputState: i.ToAzureIntegrationMapOutputWithContext(ctx).OutputState, + } +} + type AzureIntegrationOutput struct{ *pulumi.OutputState } func (AzureIntegrationOutput) ElementType() reflect.Type { @@ -266,6 +286,12 @@ func (o AzureIntegrationOutput) ToAzureIntegrationOutputWithContext(ctx context. return o } +func (o AzureIntegrationOutput) ToOutput(ctx context.Context) pulumix.Output[*AzureIntegration] { + return pulumix.Output[*AzureIntegration]{ + OutputState: o.OutputState, + } +} + // Indicates whether admin consent has been performed for the AAD Application. func (o AzureIntegrationOutput) AdminConsentProvided() pulumi.BoolOutput { return o.ApplyT(func(v *AzureIntegration) pulumi.BoolOutput { return v.AdminConsentProvided }).(pulumi.BoolOutput) @@ -325,6 +351,12 @@ func (o AzureIntegrationArrayOutput) ToAzureIntegrationArrayOutputWithContext(ct return o } +func (o AzureIntegrationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*AzureIntegration] { + return pulumix.Output[[]*AzureIntegration]{ + OutputState: o.OutputState, + } +} + func (o AzureIntegrationArrayOutput) Index(i pulumi.IntInput) AzureIntegrationOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AzureIntegration { return vs[0].([]*AzureIntegration)[vs[1].(int)] @@ -345,6 +377,12 @@ func (o AzureIntegrationMapOutput) ToAzureIntegrationMapOutputWithContext(ctx co return o } +func (o AzureIntegrationMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*AzureIntegration] { + return pulumix.Output[map[string]*AzureIntegration]{ + OutputState: o.OutputState, + } +} + func (o AzureIntegrationMapOutput) MapIndex(k pulumi.StringInput) AzureIntegrationOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AzureIntegration { return vs[0].(map[string]*AzureIntegration)[vs[1].(string)] diff --git a/sdk/go/spacelift/azureIntegrationAttachment.go b/sdk/go/spacelift/azureIntegrationAttachment.go index a3f5df7..ea07af4 100644 --- a/sdk/go/spacelift/azureIntegrationAttachment.go +++ b/sdk/go/spacelift/azureIntegrationAttachment.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AzureIntegrationAttachment` represents the attachment between a reusable Azure integration and a single stack or module. @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -93,7 +95,7 @@ func NewAzureIntegrationAttachment(ctx *pulumi.Context, if args.IntegrationId == nil { return nil, errors.New("invalid value for required argument 'IntegrationId'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource AzureIntegrationAttachment err := ctx.RegisterResource("spacelift:index/azureIntegrationAttachment:AzureIntegrationAttachment", name, args, &resource, opts...) if err != nil { @@ -207,6 +209,12 @@ func (i *AzureIntegrationAttachment) ToAzureIntegrationAttachmentOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(AzureIntegrationAttachmentOutput) } +func (i *AzureIntegrationAttachment) ToOutput(ctx context.Context) pulumix.Output[*AzureIntegrationAttachment] { + return pulumix.Output[*AzureIntegrationAttachment]{ + OutputState: i.ToAzureIntegrationAttachmentOutputWithContext(ctx).OutputState, + } +} + // AzureIntegrationAttachmentArrayInput is an input type that accepts AzureIntegrationAttachmentArray and AzureIntegrationAttachmentArrayOutput values. // You can construct a concrete instance of `AzureIntegrationAttachmentArrayInput` via: // @@ -232,6 +240,12 @@ func (i AzureIntegrationAttachmentArray) ToAzureIntegrationAttachmentArrayOutput return pulumi.ToOutputWithContext(ctx, i).(AzureIntegrationAttachmentArrayOutput) } +func (i AzureIntegrationAttachmentArray) ToOutput(ctx context.Context) pulumix.Output[[]*AzureIntegrationAttachment] { + return pulumix.Output[[]*AzureIntegrationAttachment]{ + OutputState: i.ToAzureIntegrationAttachmentArrayOutputWithContext(ctx).OutputState, + } +} + // AzureIntegrationAttachmentMapInput is an input type that accepts AzureIntegrationAttachmentMap and AzureIntegrationAttachmentMapOutput values. // You can construct a concrete instance of `AzureIntegrationAttachmentMapInput` via: // @@ -257,6 +271,12 @@ func (i AzureIntegrationAttachmentMap) ToAzureIntegrationAttachmentMapOutputWith return pulumi.ToOutputWithContext(ctx, i).(AzureIntegrationAttachmentMapOutput) } +func (i AzureIntegrationAttachmentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*AzureIntegrationAttachment] { + return pulumix.Output[map[string]*AzureIntegrationAttachment]{ + OutputState: i.ToAzureIntegrationAttachmentMapOutputWithContext(ctx).OutputState, + } +} + type AzureIntegrationAttachmentOutput struct{ *pulumi.OutputState } func (AzureIntegrationAttachmentOutput) ElementType() reflect.Type { @@ -271,6 +291,12 @@ func (o AzureIntegrationAttachmentOutput) ToAzureIntegrationAttachmentOutputWith return o } +func (o AzureIntegrationAttachmentOutput) ToOutput(ctx context.Context) pulumix.Output[*AzureIntegrationAttachment] { + return pulumix.Output[*AzureIntegrationAttachment]{ + OutputState: o.OutputState, + } +} + // Internal ID of the attachment entity func (o AzureIntegrationAttachmentOutput) AttachmentId() pulumi.StringOutput { return o.ApplyT(func(v *AzureIntegrationAttachment) pulumi.StringOutput { return v.AttachmentId }).(pulumi.StringOutput) @@ -320,6 +346,12 @@ func (o AzureIntegrationAttachmentArrayOutput) ToAzureIntegrationAttachmentArray return o } +func (o AzureIntegrationAttachmentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*AzureIntegrationAttachment] { + return pulumix.Output[[]*AzureIntegrationAttachment]{ + OutputState: o.OutputState, + } +} + func (o AzureIntegrationAttachmentArrayOutput) Index(i pulumi.IntInput) AzureIntegrationAttachmentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AzureIntegrationAttachment { return vs[0].([]*AzureIntegrationAttachment)[vs[1].(int)] @@ -340,6 +372,12 @@ func (o AzureIntegrationAttachmentMapOutput) ToAzureIntegrationAttachmentMapOutp return o } +func (o AzureIntegrationAttachmentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*AzureIntegrationAttachment] { + return pulumix.Output[map[string]*AzureIntegrationAttachment]{ + OutputState: o.OutputState, + } +} + func (o AzureIntegrationAttachmentMapOutput) MapIndex(k pulumi.StringInput) AzureIntegrationAttachmentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AzureIntegrationAttachment { return vs[0].(map[string]*AzureIntegrationAttachment)[vs[1].(string)] diff --git a/sdk/go/spacelift/blueprint.go b/sdk/go/spacelift/blueprint.go new file mode 100644 index 0000000..156e641 --- /dev/null +++ b/sdk/go/spacelift/blueprint.go @@ -0,0 +1,333 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +type Blueprint struct { + pulumi.CustomResourceState + + // Description of the blueprint + Description pulumi.StringPtrOutput `pulumi:"description"` + // Labels of the blueprint + Labels pulumi.StringArrayOutput `pulumi:"labels"` + // Name of the blueprint + Name pulumi.StringOutput `pulumi:"name"` + // ID of the space the blueprint is in + Space pulumi.StringOutput `pulumi:"space"` + // State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + State pulumi.StringOutput `pulumi:"state"` + // Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + Template pulumi.StringPtrOutput `pulumi:"template"` +} + +// NewBlueprint registers a new resource with the given unique name, arguments, and options. +func NewBlueprint(ctx *pulumi.Context, + name string, args *BlueprintArgs, opts ...pulumi.ResourceOption) (*Blueprint, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Space == nil { + return nil, errors.New("invalid value for required argument 'Space'") + } + if args.State == nil { + return nil, errors.New("invalid value for required argument 'State'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Blueprint + err := ctx.RegisterResource("spacelift:index/blueprint:Blueprint", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetBlueprint gets an existing Blueprint resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetBlueprint(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *BlueprintState, opts ...pulumi.ResourceOption) (*Blueprint, error) { + var resource Blueprint + err := ctx.ReadResource("spacelift:index/blueprint:Blueprint", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Blueprint resources. +type blueprintState struct { + // Description of the blueprint + Description *string `pulumi:"description"` + // Labels of the blueprint + Labels []string `pulumi:"labels"` + // Name of the blueprint + Name *string `pulumi:"name"` + // ID of the space the blueprint is in + Space *string `pulumi:"space"` + // State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + State *string `pulumi:"state"` + // Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + Template *string `pulumi:"template"` +} + +type BlueprintState struct { + // Description of the blueprint + Description pulumi.StringPtrInput + // Labels of the blueprint + Labels pulumi.StringArrayInput + // Name of the blueprint + Name pulumi.StringPtrInput + // ID of the space the blueprint is in + Space pulumi.StringPtrInput + // State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + State pulumi.StringPtrInput + // Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + Template pulumi.StringPtrInput +} + +func (BlueprintState) ElementType() reflect.Type { + return reflect.TypeOf((*blueprintState)(nil)).Elem() +} + +type blueprintArgs struct { + // Description of the blueprint + Description *string `pulumi:"description"` + // Labels of the blueprint + Labels []string `pulumi:"labels"` + // Name of the blueprint + Name *string `pulumi:"name"` + // ID of the space the blueprint is in + Space string `pulumi:"space"` + // State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + State string `pulumi:"state"` + // Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + Template *string `pulumi:"template"` +} + +// The set of arguments for constructing a Blueprint resource. +type BlueprintArgs struct { + // Description of the blueprint + Description pulumi.StringPtrInput + // Labels of the blueprint + Labels pulumi.StringArrayInput + // Name of the blueprint + Name pulumi.StringPtrInput + // ID of the space the blueprint is in + Space pulumi.StringInput + // State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + State pulumi.StringInput + // Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + Template pulumi.StringPtrInput +} + +func (BlueprintArgs) ElementType() reflect.Type { + return reflect.TypeOf((*blueprintArgs)(nil)).Elem() +} + +type BlueprintInput interface { + pulumi.Input + + ToBlueprintOutput() BlueprintOutput + ToBlueprintOutputWithContext(ctx context.Context) BlueprintOutput +} + +func (*Blueprint) ElementType() reflect.Type { + return reflect.TypeOf((**Blueprint)(nil)).Elem() +} + +func (i *Blueprint) ToBlueprintOutput() BlueprintOutput { + return i.ToBlueprintOutputWithContext(context.Background()) +} + +func (i *Blueprint) ToBlueprintOutputWithContext(ctx context.Context) BlueprintOutput { + return pulumi.ToOutputWithContext(ctx, i).(BlueprintOutput) +} + +func (i *Blueprint) ToOutput(ctx context.Context) pulumix.Output[*Blueprint] { + return pulumix.Output[*Blueprint]{ + OutputState: i.ToBlueprintOutputWithContext(ctx).OutputState, + } +} + +// BlueprintArrayInput is an input type that accepts BlueprintArray and BlueprintArrayOutput values. +// You can construct a concrete instance of `BlueprintArrayInput` via: +// +// BlueprintArray{ BlueprintArgs{...} } +type BlueprintArrayInput interface { + pulumi.Input + + ToBlueprintArrayOutput() BlueprintArrayOutput + ToBlueprintArrayOutputWithContext(context.Context) BlueprintArrayOutput +} + +type BlueprintArray []BlueprintInput + +func (BlueprintArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Blueprint)(nil)).Elem() +} + +func (i BlueprintArray) ToBlueprintArrayOutput() BlueprintArrayOutput { + return i.ToBlueprintArrayOutputWithContext(context.Background()) +} + +func (i BlueprintArray) ToBlueprintArrayOutputWithContext(ctx context.Context) BlueprintArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(BlueprintArrayOutput) +} + +func (i BlueprintArray) ToOutput(ctx context.Context) pulumix.Output[[]*Blueprint] { + return pulumix.Output[[]*Blueprint]{ + OutputState: i.ToBlueprintArrayOutputWithContext(ctx).OutputState, + } +} + +// BlueprintMapInput is an input type that accepts BlueprintMap and BlueprintMapOutput values. +// You can construct a concrete instance of `BlueprintMapInput` via: +// +// BlueprintMap{ "key": BlueprintArgs{...} } +type BlueprintMapInput interface { + pulumi.Input + + ToBlueprintMapOutput() BlueprintMapOutput + ToBlueprintMapOutputWithContext(context.Context) BlueprintMapOutput +} + +type BlueprintMap map[string]BlueprintInput + +func (BlueprintMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Blueprint)(nil)).Elem() +} + +func (i BlueprintMap) ToBlueprintMapOutput() BlueprintMapOutput { + return i.ToBlueprintMapOutputWithContext(context.Background()) +} + +func (i BlueprintMap) ToBlueprintMapOutputWithContext(ctx context.Context) BlueprintMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(BlueprintMapOutput) +} + +func (i BlueprintMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Blueprint] { + return pulumix.Output[map[string]*Blueprint]{ + OutputState: i.ToBlueprintMapOutputWithContext(ctx).OutputState, + } +} + +type BlueprintOutput struct{ *pulumi.OutputState } + +func (BlueprintOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Blueprint)(nil)).Elem() +} + +func (o BlueprintOutput) ToBlueprintOutput() BlueprintOutput { + return o +} + +func (o BlueprintOutput) ToBlueprintOutputWithContext(ctx context.Context) BlueprintOutput { + return o +} + +func (o BlueprintOutput) ToOutput(ctx context.Context) pulumix.Output[*Blueprint] { + return pulumix.Output[*Blueprint]{ + OutputState: o.OutputState, + } +} + +// Description of the blueprint +func (o BlueprintOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Blueprint) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// Labels of the blueprint +func (o BlueprintOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Blueprint) pulumi.StringArrayOutput { return v.Labels }).(pulumi.StringArrayOutput) +} + +// Name of the blueprint +func (o BlueprintOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Blueprint) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// ID of the space the blueprint is in +func (o BlueprintOutput) Space() pulumi.StringOutput { + return o.ApplyT(func(v *Blueprint) pulumi.StringOutput { return v.Space }).(pulumi.StringOutput) +} + +// State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. +func (o BlueprintOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v *Blueprint) pulumi.StringOutput { return v.State }).(pulumi.StringOutput) +} + +// Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. +func (o BlueprintOutput) Template() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Blueprint) pulumi.StringPtrOutput { return v.Template }).(pulumi.StringPtrOutput) +} + +type BlueprintArrayOutput struct{ *pulumi.OutputState } + +func (BlueprintArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Blueprint)(nil)).Elem() +} + +func (o BlueprintArrayOutput) ToBlueprintArrayOutput() BlueprintArrayOutput { + return o +} + +func (o BlueprintArrayOutput) ToBlueprintArrayOutputWithContext(ctx context.Context) BlueprintArrayOutput { + return o +} + +func (o BlueprintArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Blueprint] { + return pulumix.Output[[]*Blueprint]{ + OutputState: o.OutputState, + } +} + +func (o BlueprintArrayOutput) Index(i pulumi.IntInput) BlueprintOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Blueprint { + return vs[0].([]*Blueprint)[vs[1].(int)] + }).(BlueprintOutput) +} + +type BlueprintMapOutput struct{ *pulumi.OutputState } + +func (BlueprintMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Blueprint)(nil)).Elem() +} + +func (o BlueprintMapOutput) ToBlueprintMapOutput() BlueprintMapOutput { + return o +} + +func (o BlueprintMapOutput) ToBlueprintMapOutputWithContext(ctx context.Context) BlueprintMapOutput { + return o +} + +func (o BlueprintMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Blueprint] { + return pulumix.Output[map[string]*Blueprint]{ + OutputState: o.OutputState, + } +} + +func (o BlueprintMapOutput) MapIndex(k pulumi.StringInput) BlueprintOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Blueprint { + return vs[0].(map[string]*Blueprint)[vs[1].(string)] + }).(BlueprintOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*BlueprintInput)(nil)).Elem(), &Blueprint{}) + pulumi.RegisterInputType(reflect.TypeOf((*BlueprintArrayInput)(nil)).Elem(), BlueprintArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*BlueprintMapInput)(nil)).Elem(), BlueprintMap{}) + pulumi.RegisterOutputType(BlueprintOutput{}) + pulumi.RegisterOutputType(BlueprintArrayOutput{}) + pulumi.RegisterOutputType(BlueprintMapOutput{}) +} diff --git a/sdk/go/spacelift/config/config.go b/sdk/go/spacelift/config/config.go index d6cf6c2..17e3f6f 100644 --- a/sdk/go/spacelift/config/config.go +++ b/sdk/go/spacelift/config/config.go @@ -6,15 +6,22 @@ package config import ( "github.com/pulumi/pulumi/sdk/v3/go/pulumi" "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) +var _ = internal.GetEnvOrDefault + // Endpoint to use when authenticating with an API key outside of Spacelift func GetApiKeyEndpoint(ctx *pulumi.Context) string { v, err := config.Try(ctx, "spacelift:apiKeyEndpoint") if err == nil { return v } - return getEnvOrDefault("", nil, "SPACELIFT_API_KEY_ENDPOINT").(string) + var value string + if d := internal.GetEnvOrDefault(nil, nil, "SPACELIFT_API_KEY_ENDPOINT"); d != nil { + value = d.(string) + } + return value } // ID of the API key to use when executing outside of Spacelift @@ -23,7 +30,11 @@ func GetApiKeyId(ctx *pulumi.Context) string { if err == nil { return v } - return getEnvOrDefault("", nil, "SPACELIFT_API_KEY_ID").(string) + var value string + if d := internal.GetEnvOrDefault(nil, nil, "SPACELIFT_API_KEY_ID"); d != nil { + value = d.(string) + } + return value } // API key secret to use when executing outside of Spacelift @@ -32,7 +43,11 @@ func GetApiKeySecret(ctx *pulumi.Context) string { if err == nil { return v } - return getEnvOrDefault("", nil, "SPACELIFT_API_KEY_SECRET").(string) + var value string + if d := internal.GetEnvOrDefault(nil, nil, "SPACELIFT_API_KEY_SECRET"); d != nil { + value = d.(string) + } + return value } // Spacelift token generated by a run, only useful from within Spacelift @@ -41,5 +56,9 @@ func GetApiToken(ctx *pulumi.Context) string { if err == nil { return v } - return getEnvOrDefault("", nil, "SPACELIFT_API_TOKEN").(string) + var value string + if d := internal.GetEnvOrDefault(nil, nil, "SPACELIFT_API_TOKEN"); d != nil { + value = d.(string) + } + return value } diff --git a/sdk/go/spacelift/context.go b/sdk/go/spacelift/context.go index 1a05363..4a05fd7 100644 --- a/sdk/go/spacelift/context.go +++ b/sdk/go/spacelift/context.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Context` represents a Spacelift **context** - a collection of configuration elements (either environment variables or mounted files) that can be administratively attached to multiple stacks (`Stack`) or modules (`Module`) using a context attachment (`ContextAttachment`)` @@ -20,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -64,7 +66,7 @@ func NewContext(ctx *pulumi.Context, args = &ContextArgs{} } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource Context err := ctx.RegisterResource("spacelift:index/context:Context", name, args, &resource, opts...) if err != nil { @@ -154,6 +156,12 @@ func (i *Context) ToContextOutputWithContext(ctx context.Context) ContextOutput return pulumi.ToOutputWithContext(ctx, i).(ContextOutput) } +func (i *Context) ToOutput(ctx context.Context) pulumix.Output[*Context] { + return pulumix.Output[*Context]{ + OutputState: i.ToContextOutputWithContext(ctx).OutputState, + } +} + // ContextArrayInput is an input type that accepts ContextArray and ContextArrayOutput values. // You can construct a concrete instance of `ContextArrayInput` via: // @@ -179,6 +187,12 @@ func (i ContextArray) ToContextArrayOutputWithContext(ctx context.Context) Conte return pulumi.ToOutputWithContext(ctx, i).(ContextArrayOutput) } +func (i ContextArray) ToOutput(ctx context.Context) pulumix.Output[[]*Context] { + return pulumix.Output[[]*Context]{ + OutputState: i.ToContextArrayOutputWithContext(ctx).OutputState, + } +} + // ContextMapInput is an input type that accepts ContextMap and ContextMapOutput values. // You can construct a concrete instance of `ContextMapInput` via: // @@ -204,6 +218,12 @@ func (i ContextMap) ToContextMapOutputWithContext(ctx context.Context) ContextMa return pulumi.ToOutputWithContext(ctx, i).(ContextMapOutput) } +func (i ContextMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Context] { + return pulumix.Output[map[string]*Context]{ + OutputState: i.ToContextMapOutputWithContext(ctx).OutputState, + } +} + type ContextOutput struct{ *pulumi.OutputState } func (ContextOutput) ElementType() reflect.Type { @@ -218,6 +238,12 @@ func (o ContextOutput) ToContextOutputWithContext(ctx context.Context) ContextOu return o } +func (o ContextOutput) ToOutput(ctx context.Context) pulumix.Output[*Context] { + return pulumix.Output[*Context]{ + OutputState: o.OutputState, + } +} + // Free-form context description for users func (o ContextOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v *Context) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) @@ -251,6 +277,12 @@ func (o ContextArrayOutput) ToContextArrayOutputWithContext(ctx context.Context) return o } +func (o ContextArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Context] { + return pulumix.Output[[]*Context]{ + OutputState: o.OutputState, + } +} + func (o ContextArrayOutput) Index(i pulumi.IntInput) ContextOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Context { return vs[0].([]*Context)[vs[1].(int)] @@ -271,6 +303,12 @@ func (o ContextMapOutput) ToContextMapOutputWithContext(ctx context.Context) Con return o } +func (o ContextMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Context] { + return pulumix.Output[map[string]*Context]{ + OutputState: o.OutputState, + } +} + func (o ContextMapOutput) MapIndex(k pulumi.StringInput) ContextOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Context { return vs[0].(map[string]*Context)[vs[1].(string)] diff --git a/sdk/go/spacelift/contextAttachment.go b/sdk/go/spacelift/contextAttachment.go index b6b0b1a..ecb5562 100644 --- a/sdk/go/spacelift/contextAttachment.go +++ b/sdk/go/spacelift/contextAttachment.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `ContextAttachment` represents a Spacelift attachment of a single context to a single stack or module, with a predefined priority. @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -71,7 +73,7 @@ func NewContextAttachment(ctx *pulumi.Context, if args.ContextId == nil { return nil, errors.New("invalid value for required argument 'ContextId'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource ContextAttachment err := ctx.RegisterResource("spacelift:index/contextAttachment:ContextAttachment", name, args, &resource, opts...) if err != nil { @@ -165,6 +167,12 @@ func (i *ContextAttachment) ToContextAttachmentOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(ContextAttachmentOutput) } +func (i *ContextAttachment) ToOutput(ctx context.Context) pulumix.Output[*ContextAttachment] { + return pulumix.Output[*ContextAttachment]{ + OutputState: i.ToContextAttachmentOutputWithContext(ctx).OutputState, + } +} + // ContextAttachmentArrayInput is an input type that accepts ContextAttachmentArray and ContextAttachmentArrayOutput values. // You can construct a concrete instance of `ContextAttachmentArrayInput` via: // @@ -190,6 +198,12 @@ func (i ContextAttachmentArray) ToContextAttachmentArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ContextAttachmentArrayOutput) } +func (i ContextAttachmentArray) ToOutput(ctx context.Context) pulumix.Output[[]*ContextAttachment] { + return pulumix.Output[[]*ContextAttachment]{ + OutputState: i.ToContextAttachmentArrayOutputWithContext(ctx).OutputState, + } +} + // ContextAttachmentMapInput is an input type that accepts ContextAttachmentMap and ContextAttachmentMapOutput values. // You can construct a concrete instance of `ContextAttachmentMapInput` via: // @@ -215,6 +229,12 @@ func (i ContextAttachmentMap) ToContextAttachmentMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(ContextAttachmentMapOutput) } +func (i ContextAttachmentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ContextAttachment] { + return pulumix.Output[map[string]*ContextAttachment]{ + OutputState: i.ToContextAttachmentMapOutputWithContext(ctx).OutputState, + } +} + type ContextAttachmentOutput struct{ *pulumi.OutputState } func (ContextAttachmentOutput) ElementType() reflect.Type { @@ -229,6 +249,12 @@ func (o ContextAttachmentOutput) ToContextAttachmentOutputWithContext(ctx contex return o } +func (o ContextAttachmentOutput) ToOutput(ctx context.Context) pulumix.Output[*ContextAttachment] { + return pulumix.Output[*ContextAttachment]{ + OutputState: o.OutputState, + } +} + // ID of the context to attach func (o ContextAttachmentOutput) ContextId() pulumi.StringOutput { return o.ApplyT(func(v *ContextAttachment) pulumi.StringOutput { return v.ContextId }).(pulumi.StringOutput) @@ -263,6 +289,12 @@ func (o ContextAttachmentArrayOutput) ToContextAttachmentArrayOutputWithContext( return o } +func (o ContextAttachmentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ContextAttachment] { + return pulumix.Output[[]*ContextAttachment]{ + OutputState: o.OutputState, + } +} + func (o ContextAttachmentArrayOutput) Index(i pulumi.IntInput) ContextAttachmentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ContextAttachment { return vs[0].([]*ContextAttachment)[vs[1].(int)] @@ -283,6 +315,12 @@ func (o ContextAttachmentMapOutput) ToContextAttachmentMapOutputWithContext(ctx return o } +func (o ContextAttachmentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ContextAttachment] { + return pulumix.Output[map[string]*ContextAttachment]{ + OutputState: o.OutputState, + } +} + func (o ContextAttachmentMapOutput) MapIndex(k pulumi.StringInput) ContextAttachmentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ContextAttachment { return vs[0].(map[string]*ContextAttachment)[vs[1].(string)] diff --git a/sdk/go/spacelift/doc.go b/sdk/go/spacelift/doc.go index 8bcbc44..b08aef8 100644 --- a/sdk/go/spacelift/doc.go +++ b/sdk/go/spacelift/doc.go @@ -1,3 +1,2 @@ // A Pulumi package for creating and managing Spacelift resources. - package spacelift diff --git a/sdk/go/spacelift/driftDetection.go b/sdk/go/spacelift/driftDetection.go index 3f2bf9a..251888e 100644 --- a/sdk/go/spacelift/driftDetection.go +++ b/sdk/go/spacelift/driftDetection.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `DriftDetection` represents a Drift Detection configuration for a Stack. It will trigger a proposed run on the given schedule, which you can listen for using run state webhooks. If reconcile is true, then a tracked run will be triggered when drift is detected. @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -66,6 +68,8 @@ import ( type DriftDetection struct { pulumi.CustomResourceState + // Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + IgnoreState pulumi.BoolPtrOutput `pulumi:"ignoreState"` // Whether a tracked run should be triggered when drift is detected. Reconcile pulumi.BoolPtrOutput `pulumi:"reconcile"` // List of cron schedule expressions based on which drift detection should be triggered. @@ -89,7 +93,7 @@ func NewDriftDetection(ctx *pulumi.Context, if args.StackId == nil { return nil, errors.New("invalid value for required argument 'StackId'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource DriftDetection err := ctx.RegisterResource("spacelift:index/driftDetection:DriftDetection", name, args, &resource, opts...) if err != nil { @@ -112,6 +116,8 @@ func GetDriftDetection(ctx *pulumi.Context, // Input properties used for looking up and filtering DriftDetection resources. type driftDetectionState struct { + // Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + IgnoreState *bool `pulumi:"ignoreState"` // Whether a tracked run should be triggered when drift is detected. Reconcile *bool `pulumi:"reconcile"` // List of cron schedule expressions based on which drift detection should be triggered. @@ -123,6 +129,8 @@ type driftDetectionState struct { } type DriftDetectionState struct { + // Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + IgnoreState pulumi.BoolPtrInput // Whether a tracked run should be triggered when drift is detected. Reconcile pulumi.BoolPtrInput // List of cron schedule expressions based on which drift detection should be triggered. @@ -138,6 +146,8 @@ func (DriftDetectionState) ElementType() reflect.Type { } type driftDetectionArgs struct { + // Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + IgnoreState *bool `pulumi:"ignoreState"` // Whether a tracked run should be triggered when drift is detected. Reconcile *bool `pulumi:"reconcile"` // List of cron schedule expressions based on which drift detection should be triggered. @@ -150,6 +160,8 @@ type driftDetectionArgs struct { // The set of arguments for constructing a DriftDetection resource. type DriftDetectionArgs struct { + // Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + IgnoreState pulumi.BoolPtrInput // Whether a tracked run should be triggered when drift is detected. Reconcile pulumi.BoolPtrInput // List of cron schedule expressions based on which drift detection should be triggered. @@ -183,6 +195,12 @@ func (i *DriftDetection) ToDriftDetectionOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(DriftDetectionOutput) } +func (i *DriftDetection) ToOutput(ctx context.Context) pulumix.Output[*DriftDetection] { + return pulumix.Output[*DriftDetection]{ + OutputState: i.ToDriftDetectionOutputWithContext(ctx).OutputState, + } +} + // DriftDetectionArrayInput is an input type that accepts DriftDetectionArray and DriftDetectionArrayOutput values. // You can construct a concrete instance of `DriftDetectionArrayInput` via: // @@ -208,6 +226,12 @@ func (i DriftDetectionArray) ToDriftDetectionArrayOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(DriftDetectionArrayOutput) } +func (i DriftDetectionArray) ToOutput(ctx context.Context) pulumix.Output[[]*DriftDetection] { + return pulumix.Output[[]*DriftDetection]{ + OutputState: i.ToDriftDetectionArrayOutputWithContext(ctx).OutputState, + } +} + // DriftDetectionMapInput is an input type that accepts DriftDetectionMap and DriftDetectionMapOutput values. // You can construct a concrete instance of `DriftDetectionMapInput` via: // @@ -233,6 +257,12 @@ func (i DriftDetectionMap) ToDriftDetectionMapOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(DriftDetectionMapOutput) } +func (i DriftDetectionMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*DriftDetection] { + return pulumix.Output[map[string]*DriftDetection]{ + OutputState: i.ToDriftDetectionMapOutputWithContext(ctx).OutputState, + } +} + type DriftDetectionOutput struct{ *pulumi.OutputState } func (DriftDetectionOutput) ElementType() reflect.Type { @@ -247,6 +277,17 @@ func (o DriftDetectionOutput) ToDriftDetectionOutputWithContext(ctx context.Cont return o } +func (o DriftDetectionOutput) ToOutput(ctx context.Context) pulumix.Output[*DriftDetection] { + return pulumix.Output[*DriftDetection]{ + OutputState: o.OutputState, + } +} + +// Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. +func (o DriftDetectionOutput) IgnoreState() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *DriftDetection) pulumi.BoolPtrOutput { return v.IgnoreState }).(pulumi.BoolPtrOutput) +} + // Whether a tracked run should be triggered when drift is detected. func (o DriftDetectionOutput) Reconcile() pulumi.BoolPtrOutput { return o.ApplyT(func(v *DriftDetection) pulumi.BoolPtrOutput { return v.Reconcile }).(pulumi.BoolPtrOutput) @@ -281,6 +322,12 @@ func (o DriftDetectionArrayOutput) ToDriftDetectionArrayOutputWithContext(ctx co return o } +func (o DriftDetectionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*DriftDetection] { + return pulumix.Output[[]*DriftDetection]{ + OutputState: o.OutputState, + } +} + func (o DriftDetectionArrayOutput) Index(i pulumi.IntInput) DriftDetectionOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DriftDetection { return vs[0].([]*DriftDetection)[vs[1].(int)] @@ -301,6 +348,12 @@ func (o DriftDetectionMapOutput) ToDriftDetectionMapOutputWithContext(ctx contex return o } +func (o DriftDetectionMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*DriftDetection] { + return pulumix.Output[map[string]*DriftDetection]{ + OutputState: o.OutputState, + } +} + func (o DriftDetectionMapOutput) MapIndex(k pulumi.StringInput) DriftDetectionOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DriftDetection { return vs[0].(map[string]*DriftDetection)[vs[1].(string)] diff --git a/sdk/go/spacelift/environmentVariable.go b/sdk/go/spacelift/environmentVariable.go index 5023dd1..5f28866 100644 --- a/sdk/go/spacelift/environmentVariable.go +++ b/sdk/go/spacelift/environmentVariable.go @@ -7,8 +7,9 @@ import ( "context" "reflect" - "github.com/pkg/errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `EnvironmentVariable` defines an environment variable on the context (`Context`), stack (`Stack`) or a module (`Module`), thereby allowing to pass and share various secrets and configuration with Spacelift stacks. @@ -21,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -89,9 +90,9 @@ type EnvironmentVariable struct { Name pulumi.StringOutput `pulumi:"name"` // ID of the stack on which the environment variable is defined StackId pulumi.StringPtrOutput `pulumi:"stackId"` - // Value of the environment variable - Value pulumi.StringOutput `pulumi:"value"` - // Indicates whether the value can be read back outside a Run. Defaults to `true`. + // Value of the environment variable. Defaults to an empty string. + Value pulumi.StringPtrOutput `pulumi:"value"` + // Indicates whether the value is secret or not. Defaults to `true`. WriteOnly pulumi.BoolPtrOutput `pulumi:"writeOnly"` } @@ -99,13 +100,17 @@ type EnvironmentVariable struct { func NewEnvironmentVariable(ctx *pulumi.Context, name string, args *EnvironmentVariableArgs, opts ...pulumi.ResourceOption) (*EnvironmentVariable, error) { if args == nil { - return nil, errors.New("missing one or more required arguments") + args = &EnvironmentVariableArgs{} } - if args.Value == nil { - return nil, errors.New("invalid value for required argument 'Value'") + if args.Value != nil { + args.Value = pulumi.ToSecret(args.Value).(pulumi.StringPtrInput) } - opts = pkgResourceDefaultOpts(opts) + secrets := pulumi.AdditionalSecretOutputs([]string{ + "value", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) var resource EnvironmentVariable err := ctx.RegisterResource("spacelift:index/environmentVariable:EnvironmentVariable", name, args, &resource, opts...) if err != nil { @@ -138,9 +143,9 @@ type environmentVariableState struct { Name *string `pulumi:"name"` // ID of the stack on which the environment variable is defined StackId *string `pulumi:"stackId"` - // Value of the environment variable + // Value of the environment variable. Defaults to an empty string. Value *string `pulumi:"value"` - // Indicates whether the value can be read back outside a Run. Defaults to `true`. + // Indicates whether the value is secret or not. Defaults to `true`. WriteOnly *bool `pulumi:"writeOnly"` } @@ -155,9 +160,9 @@ type EnvironmentVariableState struct { Name pulumi.StringPtrInput // ID of the stack on which the environment variable is defined StackId pulumi.StringPtrInput - // Value of the environment variable + // Value of the environment variable. Defaults to an empty string. Value pulumi.StringPtrInput - // Indicates whether the value can be read back outside a Run. Defaults to `true`. + // Indicates whether the value is secret or not. Defaults to `true`. WriteOnly pulumi.BoolPtrInput } @@ -174,9 +179,9 @@ type environmentVariableArgs struct { Name *string `pulumi:"name"` // ID of the stack on which the environment variable is defined StackId *string `pulumi:"stackId"` - // Value of the environment variable - Value string `pulumi:"value"` - // Indicates whether the value can be read back outside a Run. Defaults to `true`. + // Value of the environment variable. Defaults to an empty string. + Value *string `pulumi:"value"` + // Indicates whether the value is secret or not. Defaults to `true`. WriteOnly *bool `pulumi:"writeOnly"` } @@ -190,9 +195,9 @@ type EnvironmentVariableArgs struct { Name pulumi.StringPtrInput // ID of the stack on which the environment variable is defined StackId pulumi.StringPtrInput - // Value of the environment variable - Value pulumi.StringInput - // Indicates whether the value can be read back outside a Run. Defaults to `true`. + // Value of the environment variable. Defaults to an empty string. + Value pulumi.StringPtrInput + // Indicates whether the value is secret or not. Defaults to `true`. WriteOnly pulumi.BoolPtrInput } @@ -219,6 +224,12 @@ func (i *EnvironmentVariable) ToEnvironmentVariableOutputWithContext(ctx context return pulumi.ToOutputWithContext(ctx, i).(EnvironmentVariableOutput) } +func (i *EnvironmentVariable) ToOutput(ctx context.Context) pulumix.Output[*EnvironmentVariable] { + return pulumix.Output[*EnvironmentVariable]{ + OutputState: i.ToEnvironmentVariableOutputWithContext(ctx).OutputState, + } +} + // EnvironmentVariableArrayInput is an input type that accepts EnvironmentVariableArray and EnvironmentVariableArrayOutput values. // You can construct a concrete instance of `EnvironmentVariableArrayInput` via: // @@ -244,6 +255,12 @@ func (i EnvironmentVariableArray) ToEnvironmentVariableArrayOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(EnvironmentVariableArrayOutput) } +func (i EnvironmentVariableArray) ToOutput(ctx context.Context) pulumix.Output[[]*EnvironmentVariable] { + return pulumix.Output[[]*EnvironmentVariable]{ + OutputState: i.ToEnvironmentVariableArrayOutputWithContext(ctx).OutputState, + } +} + // EnvironmentVariableMapInput is an input type that accepts EnvironmentVariableMap and EnvironmentVariableMapOutput values. // You can construct a concrete instance of `EnvironmentVariableMapInput` via: // @@ -269,6 +286,12 @@ func (i EnvironmentVariableMap) ToEnvironmentVariableMapOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(EnvironmentVariableMapOutput) } +func (i EnvironmentVariableMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*EnvironmentVariable] { + return pulumix.Output[map[string]*EnvironmentVariable]{ + OutputState: i.ToEnvironmentVariableMapOutputWithContext(ctx).OutputState, + } +} + type EnvironmentVariableOutput struct{ *pulumi.OutputState } func (EnvironmentVariableOutput) ElementType() reflect.Type { @@ -283,6 +306,12 @@ func (o EnvironmentVariableOutput) ToEnvironmentVariableOutputWithContext(ctx co return o } +func (o EnvironmentVariableOutput) ToOutput(ctx context.Context) pulumix.Output[*EnvironmentVariable] { + return pulumix.Output[*EnvironmentVariable]{ + OutputState: o.OutputState, + } +} + // SHA-256 checksum of the value func (o EnvironmentVariableOutput) Checksum() pulumi.StringOutput { return o.ApplyT(func(v *EnvironmentVariable) pulumi.StringOutput { return v.Checksum }).(pulumi.StringOutput) @@ -308,12 +337,12 @@ func (o EnvironmentVariableOutput) StackId() pulumi.StringPtrOutput { return o.ApplyT(func(v *EnvironmentVariable) pulumi.StringPtrOutput { return v.StackId }).(pulumi.StringPtrOutput) } -// Value of the environment variable -func (o EnvironmentVariableOutput) Value() pulumi.StringOutput { - return o.ApplyT(func(v *EnvironmentVariable) pulumi.StringOutput { return v.Value }).(pulumi.StringOutput) +// Value of the environment variable. Defaults to an empty string. +func (o EnvironmentVariableOutput) Value() pulumi.StringPtrOutput { + return o.ApplyT(func(v *EnvironmentVariable) pulumi.StringPtrOutput { return v.Value }).(pulumi.StringPtrOutput) } -// Indicates whether the value can be read back outside a Run. Defaults to `true`. +// Indicates whether the value is secret or not. Defaults to `true`. func (o EnvironmentVariableOutput) WriteOnly() pulumi.BoolPtrOutput { return o.ApplyT(func(v *EnvironmentVariable) pulumi.BoolPtrOutput { return v.WriteOnly }).(pulumi.BoolPtrOutput) } @@ -332,6 +361,12 @@ func (o EnvironmentVariableArrayOutput) ToEnvironmentVariableArrayOutputWithCont return o } +func (o EnvironmentVariableArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*EnvironmentVariable] { + return pulumix.Output[[]*EnvironmentVariable]{ + OutputState: o.OutputState, + } +} + func (o EnvironmentVariableArrayOutput) Index(i pulumi.IntInput) EnvironmentVariableOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EnvironmentVariable { return vs[0].([]*EnvironmentVariable)[vs[1].(int)] @@ -352,6 +387,12 @@ func (o EnvironmentVariableMapOutput) ToEnvironmentVariableMapOutputWithContext( return o } +func (o EnvironmentVariableMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*EnvironmentVariable] { + return pulumix.Output[map[string]*EnvironmentVariable]{ + OutputState: o.OutputState, + } +} + func (o EnvironmentVariableMapOutput) MapIndex(k pulumi.StringInput) EnvironmentVariableOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EnvironmentVariable { return vs[0].(map[string]*EnvironmentVariable)[vs[1].(string)] diff --git a/sdk/go/spacelift/gcpServiceAccount.go b/sdk/go/spacelift/gcpServiceAccount.go index 7b3fa22..9a29c15 100644 --- a/sdk/go/spacelift/gcpServiceAccount.go +++ b/sdk/go/spacelift/gcpServiceAccount.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // ## Example Usage @@ -20,10 +22,9 @@ import ( // // "fmt" // -// "github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/organizations" -// "github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/projects" +// "github.com/pulumi/pulumi-google/sdk/v1/go/google" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -47,19 +48,18 @@ import ( // if err != nil { // return err // } -// _, err = organizations.NewProject(ctx, "k8s-coreProject", &organizations.ProjectArgs{ -// ProjectId: pulumi.String("unicorn-k8s-core"), -// OrgId: pulumi.Any(_var.Gcp_organization_id), +// _, err = index.NewGoogle_project(ctx, "k8s-coregoogle_project", &index.Google_projectArgs{ +// Name: "Kubernetes code", +// ProjectId: "unicorn-k8s-core", +// OrgId: _var.Gcp_organization_id, // }) // if err != nil { // return err // } -// _, err = projects.NewIAMMember(ctx, "k8s-coreIAMMember", &projects.IAMMemberArgs{ -// Project: k8s_coreProject.ID(), -// Role: pulumi.String("roles/owner"), -// Member: k8s_coreGcpServiceAccount.ServiceAccountEmail.ApplyT(func(serviceAccountEmail string) (string, error) { -// return fmt.Sprintf("serviceAccount:%v", serviceAccountEmail), nil -// }).(pulumi.StringOutput), +// _, err = index.NewGoogle_project_iam_member(ctx, "k8s-coregoogle_project_iam_member", &index.Google_project_iam_memberArgs{ +// Project: k8s_coregoogle_project.Id, +// Role: "roles/owner", +// Member: pulumi.String(fmt.Sprintf("serviceAccount:%v", k8s_coreGcpServiceAccount.ServiceAccountEmail)), // }) // if err != nil { // return err @@ -106,7 +106,7 @@ func NewGcpServiceAccount(ctx *pulumi.Context, if args.TokenScopes == nil { return nil, errors.New("invalid value for required argument 'TokenScopes'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource GcpServiceAccount err := ctx.RegisterResource("spacelift:index/gcpServiceAccount:GcpServiceAccount", name, args, &resource, opts...) if err != nil { @@ -196,6 +196,12 @@ func (i *GcpServiceAccount) ToGcpServiceAccountOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(GcpServiceAccountOutput) } +func (i *GcpServiceAccount) ToOutput(ctx context.Context) pulumix.Output[*GcpServiceAccount] { + return pulumix.Output[*GcpServiceAccount]{ + OutputState: i.ToGcpServiceAccountOutputWithContext(ctx).OutputState, + } +} + // GcpServiceAccountArrayInput is an input type that accepts GcpServiceAccountArray and GcpServiceAccountArrayOutput values. // You can construct a concrete instance of `GcpServiceAccountArrayInput` via: // @@ -221,6 +227,12 @@ func (i GcpServiceAccountArray) ToGcpServiceAccountArrayOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(GcpServiceAccountArrayOutput) } +func (i GcpServiceAccountArray) ToOutput(ctx context.Context) pulumix.Output[[]*GcpServiceAccount] { + return pulumix.Output[[]*GcpServiceAccount]{ + OutputState: i.ToGcpServiceAccountArrayOutputWithContext(ctx).OutputState, + } +} + // GcpServiceAccountMapInput is an input type that accepts GcpServiceAccountMap and GcpServiceAccountMapOutput values. // You can construct a concrete instance of `GcpServiceAccountMapInput` via: // @@ -246,6 +258,12 @@ func (i GcpServiceAccountMap) ToGcpServiceAccountMapOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(GcpServiceAccountMapOutput) } +func (i GcpServiceAccountMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*GcpServiceAccount] { + return pulumix.Output[map[string]*GcpServiceAccount]{ + OutputState: i.ToGcpServiceAccountMapOutputWithContext(ctx).OutputState, + } +} + type GcpServiceAccountOutput struct{ *pulumi.OutputState } func (GcpServiceAccountOutput) ElementType() reflect.Type { @@ -260,6 +278,12 @@ func (o GcpServiceAccountOutput) ToGcpServiceAccountOutputWithContext(ctx contex return o } +func (o GcpServiceAccountOutput) ToOutput(ctx context.Context) pulumix.Output[*GcpServiceAccount] { + return pulumix.Output[*GcpServiceAccount]{ + OutputState: o.OutputState, + } +} + // ID of the module which uses GCP service account credentials func (o GcpServiceAccountOutput) ModuleId() pulumi.StringPtrOutput { return o.ApplyT(func(v *GcpServiceAccount) pulumi.StringPtrOutput { return v.ModuleId }).(pulumi.StringPtrOutput) @@ -294,6 +318,12 @@ func (o GcpServiceAccountArrayOutput) ToGcpServiceAccountArrayOutputWithContext( return o } +func (o GcpServiceAccountArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*GcpServiceAccount] { + return pulumix.Output[[]*GcpServiceAccount]{ + OutputState: o.OutputState, + } +} + func (o GcpServiceAccountArrayOutput) Index(i pulumi.IntInput) GcpServiceAccountOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *GcpServiceAccount { return vs[0].([]*GcpServiceAccount)[vs[1].(int)] @@ -314,6 +344,12 @@ func (o GcpServiceAccountMapOutput) ToGcpServiceAccountMapOutputWithContext(ctx return o } +func (o GcpServiceAccountMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*GcpServiceAccount] { + return pulumix.Output[map[string]*GcpServiceAccount]{ + OutputState: o.OutputState, + } +} + func (o GcpServiceAccountMapOutput) MapIndex(k pulumi.StringInput) GcpServiceAccountOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *GcpServiceAccount { return vs[0].(map[string]*GcpServiceAccount)[vs[1].(string)] diff --git a/sdk/go/spacelift/getAccount.go b/sdk/go/spacelift/getAccount.go index 40739b9..ec98802 100644 --- a/sdk/go/spacelift/getAccount.go +++ b/sdk/go/spacelift/getAccount.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getAccount` represents the currently used Spacelift **account** @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetAccount(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetAccountResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetAccountResult err := ctx.Invoke("spacelift:index/getAccount:getAccount", nil, &rv, opts...) if err != nil { @@ -53,3 +58,59 @@ type GetAccountResult struct { // account billing tier Tier string `pulumi:"tier"` } + +func GetAccountOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetAccountResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetAccountResult, error) { + r, err := GetAccount(ctx, opts...) + var s GetAccountResult + if r != nil { + s = *r + } + return s, err + }).(GetAccountResultOutput) +} + +// A collection of values returned by getAccount. +type GetAccountResultOutput struct{ *pulumi.OutputState } + +func (GetAccountResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetAccountResult)(nil)).Elem() +} + +func (o GetAccountResultOutput) ToGetAccountResultOutput() GetAccountResultOutput { + return o +} + +func (o GetAccountResultOutput) ToGetAccountResultOutputWithContext(ctx context.Context) GetAccountResultOutput { + return o +} + +func (o GetAccountResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetAccountResult] { + return pulumix.Output[GetAccountResult]{ + OutputState: o.OutputState, + } +} + +// the ID of the AWS account used by Spacelift for role assumption +func (o GetAccountResultOutput) AwsAccountId() pulumi.StringOutput { + return o.ApplyT(func(v GetAccountResult) string { return v.AwsAccountId }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetAccountResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetAccountResult) string { return v.Id }).(pulumi.StringOutput) +} + +// name of the account +func (o GetAccountResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetAccountResult) string { return v.Name }).(pulumi.StringOutput) +} + +// account billing tier +func (o GetAccountResultOutput) Tier() pulumi.StringOutput { + return o.ApplyT(func(v GetAccountResult) string { return v.Tier }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetAccountResultOutput{}) +} diff --git a/sdk/go/spacelift/getAwsIntegration.go b/sdk/go/spacelift/getAwsIntegration.go index bced8c6..7d5c10a 100644 --- a/sdk/go/spacelift/getAwsIntegration.go +++ b/sdk/go/spacelift/getAwsIntegration.go @@ -8,11 +8,13 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. // -// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. +// Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. // // ## Example Usage // @@ -22,13 +24,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupAwsIntegration(ctx, &GetAwsIntegrationArgs{ +// _, err := spacelift.LookupAwsIntegration(ctx, &spacelift.LookupAwsIntegrationArgs{ // Name: pulumi.StringRef("Production"), // }, nil) // if err != nil { @@ -40,7 +42,7 @@ import ( // // ``` func LookupAwsIntegration(ctx *pulumi.Context, args *LookupAwsIntegrationArgs, opts ...pulumi.InvokeOption) (*LookupAwsIntegrationResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupAwsIntegrationResult err := ctx.Invoke("spacelift:index/getAwsIntegration:getAwsIntegration", args, &rv, opts...) if err != nil { @@ -118,6 +120,12 @@ func (o LookupAwsIntegrationResultOutput) ToLookupAwsIntegrationResultOutputWith return o } +func (o LookupAwsIntegrationResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupAwsIntegrationResult] { + return pulumix.Output[LookupAwsIntegrationResult]{ + OutputState: o.OutputState, + } +} + // Duration in seconds for which the assumed role credentials should be valid func (o LookupAwsIntegrationResultOutput) DurationSeconds() pulumi.IntOutput { return o.ApplyT(func(v LookupAwsIntegrationResult) int { return v.DurationSeconds }).(pulumi.IntOutput) diff --git a/sdk/go/spacelift/getAwsIntegrationAttachment.go b/sdk/go/spacelift/getAwsIntegrationAttachment.go index 01b4ac6..8db06f5 100644 --- a/sdk/go/spacelift/getAwsIntegrationAttachment.go +++ b/sdk/go/spacelift/getAwsIntegrationAttachment.go @@ -8,11 +8,13 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AwsIntegrationAttachment` represents the attachment between a reusable AWS integration and a single stack or module. func LookupAwsIntegrationAttachment(ctx *pulumi.Context, args *LookupAwsIntegrationAttachmentArgs, opts ...pulumi.InvokeOption) (*LookupAwsIntegrationAttachmentResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupAwsIntegrationAttachmentResult err := ctx.Invoke("spacelift:index/getAwsIntegrationAttachment:getAwsIntegrationAttachment", args, &rv, opts...) if err != nil { @@ -91,6 +93,12 @@ func (o LookupAwsIntegrationAttachmentResultOutput) ToLookupAwsIntegrationAttach return o } +func (o LookupAwsIntegrationAttachmentResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupAwsIntegrationAttachmentResult] { + return pulumix.Output[LookupAwsIntegrationAttachmentResult]{ + OutputState: o.OutputState, + } +} + // Internal ID of the attachment entity func (o LookupAwsIntegrationAttachmentResultOutput) AttachmentId() pulumi.StringOutput { return o.ApplyT(func(v LookupAwsIntegrationAttachmentResult) string { return v.AttachmentId }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getAwsIntegrationAttachmentExternalId.go b/sdk/go/spacelift/getAwsIntegrationAttachmentExternalId.go index 6efc83b..248c18b 100644 --- a/sdk/go/spacelift/getAwsIntegrationAttachmentExternalId.go +++ b/sdk/go/spacelift/getAwsIntegrationAttachmentExternalId.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getAwsIntegrationAttachmentExternalId` is used to generate the external ID that would be used for role assumption when an AWS integration is attached to a stack or module. @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.GetAwsIntegrationAttachmentExternalId(ctx, &GetAwsIntegrationAttachmentExternalIdArgs{ +// _, err := spacelift.GetAwsIntegrationAttachmentExternalId(ctx, &spacelift.GetAwsIntegrationAttachmentExternalIdArgs{ // IntegrationId: spacelift_aws_integration.This.Id, // StackId: pulumi.StringRef("my-stack-id"), // Read: pulumi.BoolRef(true), @@ -35,7 +37,7 @@ import ( // if err != nil { // return err // } -// _, err = spacelift.GetAwsIntegrationAttachmentExternalId(ctx, &GetAwsIntegrationAttachmentExternalIdArgs{ +// _, err = spacelift.GetAwsIntegrationAttachmentExternalId(ctx, &spacelift.GetAwsIntegrationAttachmentExternalIdArgs{ // IntegrationId: spacelift_aws_integration.This.Id, // ModuleId: pulumi.StringRef("my-module-id"), // Read: pulumi.BoolRef(true), @@ -50,7 +52,7 @@ import ( // // ``` func GetAwsIntegrationAttachmentExternalId(ctx *pulumi.Context, args *GetAwsIntegrationAttachmentExternalIdArgs, opts ...pulumi.InvokeOption) (*GetAwsIntegrationAttachmentExternalIdResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetAwsIntegrationAttachmentExternalIdResult err := ctx.Invoke("spacelift:index/getAwsIntegrationAttachmentExternalId:getAwsIntegrationAttachmentExternalId", args, &rv, opts...) if err != nil { @@ -139,6 +141,12 @@ func (o GetAwsIntegrationAttachmentExternalIdResultOutput) ToGetAwsIntegrationAt return o } +func (o GetAwsIntegrationAttachmentExternalIdResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetAwsIntegrationAttachmentExternalIdResult] { + return pulumix.Output[GetAwsIntegrationAttachmentExternalIdResult]{ + OutputState: o.OutputState, + } +} + // An assume role policy statement that can be attached to your role to allow Spacelift to assume it func (o GetAwsIntegrationAttachmentExternalIdResultOutput) AssumeRolePolicyStatement() pulumi.StringOutput { return o.ApplyT(func(v GetAwsIntegrationAttachmentExternalIdResult) string { return v.AssumeRolePolicyStatement }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getAwsIntegrations.go b/sdk/go/spacelift/getAwsIntegrations.go new file mode 100644 index 0000000..e36f865 --- /dev/null +++ b/sdk/go/spacelift/getAwsIntegrations.go @@ -0,0 +1,76 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `getAwsIntegrations` represents a list of all the AWS integrations in the Spacelift account visible to the API user. +func GetAwsIntegrations(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetAwsIntegrationsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetAwsIntegrationsResult + err := ctx.Invoke("spacelift:index/getAwsIntegrations:getAwsIntegrations", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getAwsIntegrations. +type GetAwsIntegrationsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Integrations []GetAwsIntegrationsIntegration `pulumi:"integrations"` +} + +func GetAwsIntegrationsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetAwsIntegrationsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetAwsIntegrationsResult, error) { + r, err := GetAwsIntegrations(ctx, opts...) + var s GetAwsIntegrationsResult + if r != nil { + s = *r + } + return s, err + }).(GetAwsIntegrationsResultOutput) +} + +// A collection of values returned by getAwsIntegrations. +type GetAwsIntegrationsResultOutput struct{ *pulumi.OutputState } + +func (GetAwsIntegrationsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetAwsIntegrationsResult)(nil)).Elem() +} + +func (o GetAwsIntegrationsResultOutput) ToGetAwsIntegrationsResultOutput() GetAwsIntegrationsResultOutput { + return o +} + +func (o GetAwsIntegrationsResultOutput) ToGetAwsIntegrationsResultOutputWithContext(ctx context.Context) GetAwsIntegrationsResultOutput { + return o +} + +func (o GetAwsIntegrationsResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetAwsIntegrationsResult] { + return pulumix.Output[GetAwsIntegrationsResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetAwsIntegrationsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetAwsIntegrationsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetAwsIntegrationsResultOutput) Integrations() GetAwsIntegrationsIntegrationArrayOutput { + return o.ApplyT(func(v GetAwsIntegrationsResult) []GetAwsIntegrationsIntegration { return v.Integrations }).(GetAwsIntegrationsIntegrationArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetAwsIntegrationsResultOutput{}) +} diff --git a/sdk/go/spacelift/getAwsRole.go b/sdk/go/spacelift/getAwsRole.go index b0e28b9..7822e6f 100644 --- a/sdk/go/spacelift/getAwsRole.go +++ b/sdk/go/spacelift/getAwsRole.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AwsRole` represents [cross-account IAM role delegation](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) between the Spacelift worker and an individual stack or module. If this is set, Spacelift will use AWS STS to assume the supplied IAM role and put its temporary credentials in the runtime environment. @@ -24,19 +26,19 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupAwsRole(ctx, &GetAwsRoleArgs{ +// _, err := spacelift.LookupAwsRole(ctx, &spacelift.LookupAwsRoleArgs{ // ModuleId: pulumi.StringRef("k8s-module"), // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupAwsRole(ctx, &GetAwsRoleArgs{ +// _, err = spacelift.LookupAwsRole(ctx, &spacelift.LookupAwsRoleArgs{ // StackId: pulumi.StringRef("k8s-core"), // }, nil) // if err != nil { @@ -48,7 +50,7 @@ import ( // // ``` func LookupAwsRole(ctx *pulumi.Context, args *LookupAwsRoleArgs, opts ...pulumi.InvokeOption) (*LookupAwsRoleResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupAwsRoleResult err := ctx.Invoke("spacelift:index/getAwsRole:getAwsRole", args, &rv, opts...) if err != nil { @@ -123,6 +125,12 @@ func (o LookupAwsRoleResultOutput) ToLookupAwsRoleResultOutputWithContext(ctx co return o } +func (o LookupAwsRoleResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupAwsRoleResult] { + return pulumix.Output[LookupAwsRoleResult]{ + OutputState: o.OutputState, + } +} + // AWS IAM role session duration in seconds func (o LookupAwsRoleResultOutput) DurationSeconds() pulumi.IntOutput { return o.ApplyT(func(v LookupAwsRoleResult) int { return v.DurationSeconds }).(pulumi.IntOutput) diff --git a/sdk/go/spacelift/getAzureDevopsIntegration.go b/sdk/go/spacelift/getAzureDevopsIntegration.go index fae35b6..f0afe87 100644 --- a/sdk/go/spacelift/getAzureDevopsIntegration.go +++ b/sdk/go/spacelift/getAzureDevopsIntegration.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getAzureDevopsIntegration` returns details about Azure DevOps integration @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetAzureDevopsIntegration(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetAzureDevopsIntegrationResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetAzureDevopsIntegrationResult err := ctx.Invoke("spacelift:index/getAzureDevopsIntegration:getAzureDevopsIntegration", nil, &rv, opts...) if err != nil { @@ -51,3 +56,54 @@ type GetAzureDevopsIntegrationResult struct { // Azure DevOps integration webhook password WebhookPassword string `pulumi:"webhookPassword"` } + +func GetAzureDevopsIntegrationOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetAzureDevopsIntegrationResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetAzureDevopsIntegrationResult, error) { + r, err := GetAzureDevopsIntegration(ctx, opts...) + var s GetAzureDevopsIntegrationResult + if r != nil { + s = *r + } + return s, err + }).(GetAzureDevopsIntegrationResultOutput) +} + +// A collection of values returned by getAzureDevopsIntegration. +type GetAzureDevopsIntegrationResultOutput struct{ *pulumi.OutputState } + +func (GetAzureDevopsIntegrationResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetAzureDevopsIntegrationResult)(nil)).Elem() +} + +func (o GetAzureDevopsIntegrationResultOutput) ToGetAzureDevopsIntegrationResultOutput() GetAzureDevopsIntegrationResultOutput { + return o +} + +func (o GetAzureDevopsIntegrationResultOutput) ToGetAzureDevopsIntegrationResultOutputWithContext(ctx context.Context) GetAzureDevopsIntegrationResultOutput { + return o +} + +func (o GetAzureDevopsIntegrationResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetAzureDevopsIntegrationResult] { + return pulumix.Output[GetAzureDevopsIntegrationResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetAzureDevopsIntegrationResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureDevopsIntegrationResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Azure DevOps integration organization url +func (o GetAzureDevopsIntegrationResultOutput) OrganizationUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureDevopsIntegrationResult) string { return v.OrganizationUrl }).(pulumi.StringOutput) +} + +// Azure DevOps integration webhook password +func (o GetAzureDevopsIntegrationResultOutput) WebhookPassword() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureDevopsIntegrationResult) string { return v.WebhookPassword }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetAzureDevopsIntegrationResultOutput{}) +} diff --git a/sdk/go/spacelift/getAzureIntegration.go b/sdk/go/spacelift/getAzureIntegration.go index 8c02a29..e80276e 100644 --- a/sdk/go/spacelift/getAzureIntegration.go +++ b/sdk/go/spacelift/getAzureIntegration.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AzureIntegration` represents an integration with an Azure AD tenant. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. Note that you will need to provide admin consent manually for the integration to work @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupAzureIntegration(ctx, &GetAzureIntegrationArgs{ +// _, err := spacelift.LookupAzureIntegration(ctx, &spacelift.LookupAzureIntegrationArgs{ // Name: pulumi.StringRef("Production"), // }, nil) // if err != nil { @@ -38,7 +40,7 @@ import ( // // ``` func LookupAzureIntegration(ctx *pulumi.Context, args *LookupAzureIntegrationArgs, opts ...pulumi.InvokeOption) (*LookupAzureIntegrationResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupAzureIntegrationResult err := ctx.Invoke("spacelift:index/getAzureIntegration:getAzureIntegration", args, &rv, opts...) if err != nil { @@ -121,6 +123,12 @@ func (o LookupAzureIntegrationResultOutput) ToLookupAzureIntegrationResultOutput return o } +func (o LookupAzureIntegrationResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupAzureIntegrationResult] { + return pulumix.Output[LookupAzureIntegrationResult]{ + OutputState: o.OutputState, + } +} + // Indicates whether admin consent has been performed for the AAD Application. func (o LookupAzureIntegrationResultOutput) AdminConsentProvided() pulumi.BoolOutput { return o.ApplyT(func(v LookupAzureIntegrationResult) bool { return v.AdminConsentProvided }).(pulumi.BoolOutput) diff --git a/sdk/go/spacelift/getAzureIntegrationAttachment.go b/sdk/go/spacelift/getAzureIntegrationAttachment.go index 24d534a..da3accd 100644 --- a/sdk/go/spacelift/getAzureIntegrationAttachment.go +++ b/sdk/go/spacelift/getAzureIntegrationAttachment.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `AzureIntegrationAttachment` represents the attachment between a reusable Azure integration and a single stack or module. @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupAzureIntegrationAttachment(ctx, &GetAzureIntegrationAttachmentArgs{ +// _, err := spacelift.LookupAzureIntegrationAttachment(ctx, &spacelift.LookupAzureIntegrationAttachmentArgs{ // IntegrationId: "some-integration-id", // StackId: pulumi.StringRef("some-stack-id"), // }, nil) @@ -39,7 +41,7 @@ import ( // // ``` func LookupAzureIntegrationAttachment(ctx *pulumi.Context, args *LookupAzureIntegrationAttachmentArgs, opts ...pulumi.InvokeOption) (*LookupAzureIntegrationAttachmentResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupAzureIntegrationAttachmentResult err := ctx.Invoke("spacelift:index/getAzureIntegrationAttachment:getAzureIntegrationAttachment", args, &rv, opts...) if err != nil { @@ -120,6 +122,12 @@ func (o LookupAzureIntegrationAttachmentResultOutput) ToLookupAzureIntegrationAt return o } +func (o LookupAzureIntegrationAttachmentResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupAzureIntegrationAttachmentResult] { + return pulumix.Output[LookupAzureIntegrationAttachmentResult]{ + OutputState: o.OutputState, + } +} + // Internal ID of the attachment entity func (o LookupAzureIntegrationAttachmentResultOutput) AttachmentId() pulumi.StringOutput { return o.ApplyT(func(v LookupAzureIntegrationAttachmentResult) string { return v.AttachmentId }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getAzureIntegrations.go b/sdk/go/spacelift/getAzureIntegrations.go new file mode 100644 index 0000000..9b317eb --- /dev/null +++ b/sdk/go/spacelift/getAzureIntegrations.go @@ -0,0 +1,76 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `getAzureIntegrations` represents a list of all the Azure integrations in the Spacelift account visible to the API user. +func GetAzureIntegrations(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetAzureIntegrationsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetAzureIntegrationsResult + err := ctx.Invoke("spacelift:index/getAzureIntegrations:getAzureIntegrations", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getAzureIntegrations. +type GetAzureIntegrationsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Integrations []GetAzureIntegrationsIntegration `pulumi:"integrations"` +} + +func GetAzureIntegrationsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetAzureIntegrationsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetAzureIntegrationsResult, error) { + r, err := GetAzureIntegrations(ctx, opts...) + var s GetAzureIntegrationsResult + if r != nil { + s = *r + } + return s, err + }).(GetAzureIntegrationsResultOutput) +} + +// A collection of values returned by getAzureIntegrations. +type GetAzureIntegrationsResultOutput struct{ *pulumi.OutputState } + +func (GetAzureIntegrationsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetAzureIntegrationsResult)(nil)).Elem() +} + +func (o GetAzureIntegrationsResultOutput) ToGetAzureIntegrationsResultOutput() GetAzureIntegrationsResultOutput { + return o +} + +func (o GetAzureIntegrationsResultOutput) ToGetAzureIntegrationsResultOutputWithContext(ctx context.Context) GetAzureIntegrationsResultOutput { + return o +} + +func (o GetAzureIntegrationsResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetAzureIntegrationsResult] { + return pulumix.Output[GetAzureIntegrationsResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetAzureIntegrationsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetAzureIntegrationsResultOutput) Integrations() GetAzureIntegrationsIntegrationArrayOutput { + return o.ApplyT(func(v GetAzureIntegrationsResult) []GetAzureIntegrationsIntegration { return v.Integrations }).(GetAzureIntegrationsIntegrationArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetAzureIntegrationsResultOutput{}) +} diff --git a/sdk/go/spacelift/getBitbucketCloudIntegration.go b/sdk/go/spacelift/getBitbucketCloudIntegration.go index 3ef47f7..a6e3ec5 100644 --- a/sdk/go/spacelift/getBitbucketCloudIntegration.go +++ b/sdk/go/spacelift/getBitbucketCloudIntegration.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getBitbucketCloudIntegration` returns details about Bitbucket Cloud integration @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetBitbucketCloudIntegration(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetBitbucketCloudIntegrationResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetBitbucketCloudIntegrationResult err := ctx.Invoke("spacelift:index/getBitbucketCloudIntegration:getBitbucketCloudIntegration", nil, &rv, opts...) if err != nil { @@ -49,3 +54,49 @@ type GetBitbucketCloudIntegrationResult struct { // Bitbucket Cloud username Username string `pulumi:"username"` } + +func GetBitbucketCloudIntegrationOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetBitbucketCloudIntegrationResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetBitbucketCloudIntegrationResult, error) { + r, err := GetBitbucketCloudIntegration(ctx, opts...) + var s GetBitbucketCloudIntegrationResult + if r != nil { + s = *r + } + return s, err + }).(GetBitbucketCloudIntegrationResultOutput) +} + +// A collection of values returned by getBitbucketCloudIntegration. +type GetBitbucketCloudIntegrationResultOutput struct{ *pulumi.OutputState } + +func (GetBitbucketCloudIntegrationResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetBitbucketCloudIntegrationResult)(nil)).Elem() +} + +func (o GetBitbucketCloudIntegrationResultOutput) ToGetBitbucketCloudIntegrationResultOutput() GetBitbucketCloudIntegrationResultOutput { + return o +} + +func (o GetBitbucketCloudIntegrationResultOutput) ToGetBitbucketCloudIntegrationResultOutputWithContext(ctx context.Context) GetBitbucketCloudIntegrationResultOutput { + return o +} + +func (o GetBitbucketCloudIntegrationResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetBitbucketCloudIntegrationResult] { + return pulumix.Output[GetBitbucketCloudIntegrationResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetBitbucketCloudIntegrationResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetBitbucketCloudIntegrationResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Bitbucket Cloud username +func (o GetBitbucketCloudIntegrationResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v GetBitbucketCloudIntegrationResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetBitbucketCloudIntegrationResultOutput{}) +} diff --git a/sdk/go/spacelift/getBitbucketDatacenterIntegration.go b/sdk/go/spacelift/getBitbucketDatacenterIntegration.go index 5fdeed1..4b46fd4 100644 --- a/sdk/go/spacelift/getBitbucketDatacenterIntegration.go +++ b/sdk/go/spacelift/getBitbucketDatacenterIntegration.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getBitbucketDatacenterIntegration` returns details about Bitbucket Datacenter integration @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetBitbucketDatacenterIntegration(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetBitbucketDatacenterIntegrationResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetBitbucketDatacenterIntegrationResult err := ctx.Invoke("spacelift:index/getBitbucketDatacenterIntegration:getBitbucketDatacenterIntegration", nil, &rv, opts...) if err != nil { @@ -52,4 +57,67 @@ type GetBitbucketDatacenterIntegrationResult struct { UserFacingHost string `pulumi:"userFacingHost"` // Bitbucket Datacenter integration webhook secret WebhookSecret string `pulumi:"webhookSecret"` + // Bitbucket Datacenter integration webhook URL + WebhookUrl string `pulumi:"webhookUrl"` +} + +func GetBitbucketDatacenterIntegrationOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetBitbucketDatacenterIntegrationResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetBitbucketDatacenterIntegrationResult, error) { + r, err := GetBitbucketDatacenterIntegration(ctx, opts...) + var s GetBitbucketDatacenterIntegrationResult + if r != nil { + s = *r + } + return s, err + }).(GetBitbucketDatacenterIntegrationResultOutput) +} + +// A collection of values returned by getBitbucketDatacenterIntegration. +type GetBitbucketDatacenterIntegrationResultOutput struct{ *pulumi.OutputState } + +func (GetBitbucketDatacenterIntegrationResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetBitbucketDatacenterIntegrationResult)(nil)).Elem() +} + +func (o GetBitbucketDatacenterIntegrationResultOutput) ToGetBitbucketDatacenterIntegrationResultOutput() GetBitbucketDatacenterIntegrationResultOutput { + return o +} + +func (o GetBitbucketDatacenterIntegrationResultOutput) ToGetBitbucketDatacenterIntegrationResultOutputWithContext(ctx context.Context) GetBitbucketDatacenterIntegrationResultOutput { + return o +} + +func (o GetBitbucketDatacenterIntegrationResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetBitbucketDatacenterIntegrationResult] { + return pulumix.Output[GetBitbucketDatacenterIntegrationResult]{ + OutputState: o.OutputState, + } +} + +// Bitbucket Datacenter integration api host +func (o GetBitbucketDatacenterIntegrationResultOutput) ApiHost() pulumi.StringOutput { + return o.ApplyT(func(v GetBitbucketDatacenterIntegrationResult) string { return v.ApiHost }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetBitbucketDatacenterIntegrationResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetBitbucketDatacenterIntegrationResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Bitbucket Datacenter integration user facing host +func (o GetBitbucketDatacenterIntegrationResultOutput) UserFacingHost() pulumi.StringOutput { + return o.ApplyT(func(v GetBitbucketDatacenterIntegrationResult) string { return v.UserFacingHost }).(pulumi.StringOutput) +} + +// Bitbucket Datacenter integration webhook secret +func (o GetBitbucketDatacenterIntegrationResultOutput) WebhookSecret() pulumi.StringOutput { + return o.ApplyT(func(v GetBitbucketDatacenterIntegrationResult) string { return v.WebhookSecret }).(pulumi.StringOutput) +} + +// Bitbucket Datacenter integration webhook URL +func (o GetBitbucketDatacenterIntegrationResultOutput) WebhookUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetBitbucketDatacenterIntegrationResult) string { return v.WebhookUrl }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetBitbucketDatacenterIntegrationResultOutput{}) } diff --git a/sdk/go/spacelift/getContext.go b/sdk/go/spacelift/getContext.go index 08e7289..49d1a18 100644 --- a/sdk/go/spacelift/getContext.go +++ b/sdk/go/spacelift/getContext.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Context` represents a Spacelift **context** - a collection of configuration elements (either environment variables or mounted files) that can be administratively attached to multiple stacks (`Stack`) or modules (`Module`) using a context attachment (`ContextAttachment`)` @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupContext(ctx, &GetContextArgs{ +// _, err := spacelift.LookupContext(ctx, &spacelift.LookupContextArgs{ // ContextId: "prod-k8s-ie", // }, nil) // if err != nil { @@ -38,7 +40,7 @@ import ( // // ``` func LookupContext(ctx *pulumi.Context, args *LookupContextArgs, opts ...pulumi.InvokeOption) (*LookupContextResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupContextResult err := ctx.Invoke("spacelift:index/getContext:getContext", args, &rv, opts...) if err != nil { @@ -106,6 +108,12 @@ func (o LookupContextResultOutput) ToLookupContextResultOutputWithContext(ctx co return o } +func (o LookupContextResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupContextResult] { + return pulumix.Output[LookupContextResult]{ + OutputState: o.OutputState, + } +} + // immutable ID (slug) of the context func (o LookupContextResultOutput) ContextId() pulumi.StringOutput { return o.ApplyT(func(v LookupContextResult) string { return v.ContextId }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getContextAttachment.go b/sdk/go/spacelift/getContextAttachment.go index 6d5bbe6..fad220d 100644 --- a/sdk/go/spacelift/getContextAttachment.go +++ b/sdk/go/spacelift/getContextAttachment.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `ContextAttachment` represents a Spacelift attachment of a single context to a single stack or module, with a predefined priority. @@ -20,20 +22,20 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupContextAttachment(ctx, &GetContextAttachmentArgs{ +// _, err := spacelift.LookupContextAttachment(ctx, &spacelift.LookupContextAttachmentArgs{ // ContextId: "prod-k8s-ie", // StackId: pulumi.StringRef("apps-cluster"), // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupContextAttachment(ctx, &GetContextAttachmentArgs{ +// _, err = spacelift.LookupContextAttachment(ctx, &spacelift.LookupContextAttachmentArgs{ // ContextId: "prod-k8s-ie", // ModuleId: pulumi.StringRef("terraform-aws-kafka"), // }, nil) @@ -46,7 +48,7 @@ import ( // // ``` func LookupContextAttachment(ctx *pulumi.Context, args *LookupContextAttachmentArgs, opts ...pulumi.InvokeOption) (*LookupContextAttachmentResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupContextAttachmentResult err := ctx.Invoke("spacelift:index/getContextAttachment:getContextAttachment", args, &rv, opts...) if err != nil { @@ -121,6 +123,12 @@ func (o LookupContextAttachmentResultOutput) ToLookupContextAttachmentResultOutp return o } +func (o LookupContextAttachmentResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupContextAttachmentResult] { + return pulumix.Output[LookupContextAttachmentResult]{ + OutputState: o.OutputState, + } +} + // ID of the attached context func (o LookupContextAttachmentResultOutput) ContextId() pulumi.StringOutput { return o.ApplyT(func(v LookupContextAttachmentResult) string { return v.ContextId }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getContexts.go b/sdk/go/spacelift/getContexts.go new file mode 100644 index 0000000..e8e4377 --- /dev/null +++ b/sdk/go/spacelift/getContexts.go @@ -0,0 +1,137 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `getContexts` represents all the contexts in the Spacelift account visible to the API user. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := spacelift.GetContexts(ctx, &spacelift.GetContextsArgs{ +// Labels: []spacelift.GetContextsLabel{ +// { +// AnyOfs: []string{ +// "foo", +// "bar", +// }, +// }, +// { +// AnyOfs: []string{ +// "baz", +// }, +// }, +// }, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetContexts(ctx *pulumi.Context, args *GetContextsArgs, opts ...pulumi.InvokeOption) (*GetContextsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetContextsResult + err := ctx.Invoke("spacelift:index/getContexts:getContexts", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getContexts. +type GetContextsArgs struct { + Labels []GetContextsLabel `pulumi:"labels"` +} + +// A collection of values returned by getContexts. +type GetContextsResult struct { + Contexts []GetContextsContext `pulumi:"contexts"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Require contexts to have one of the labels + Labels []GetContextsLabel `pulumi:"labels"` +} + +func GetContextsOutput(ctx *pulumi.Context, args GetContextsOutputArgs, opts ...pulumi.InvokeOption) GetContextsResultOutput { + return pulumi.ToOutputWithContext(context.Background(), args). + ApplyT(func(v interface{}) (GetContextsResult, error) { + args := v.(GetContextsArgs) + r, err := GetContexts(ctx, &args, opts...) + var s GetContextsResult + if r != nil { + s = *r + } + return s, err + }).(GetContextsResultOutput) +} + +// A collection of arguments for invoking getContexts. +type GetContextsOutputArgs struct { + Labels GetContextsLabelArrayInput `pulumi:"labels"` +} + +func (GetContextsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetContextsArgs)(nil)).Elem() +} + +// A collection of values returned by getContexts. +type GetContextsResultOutput struct{ *pulumi.OutputState } + +func (GetContextsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetContextsResult)(nil)).Elem() +} + +func (o GetContextsResultOutput) ToGetContextsResultOutput() GetContextsResultOutput { + return o +} + +func (o GetContextsResultOutput) ToGetContextsResultOutputWithContext(ctx context.Context) GetContextsResultOutput { + return o +} + +func (o GetContextsResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetContextsResult] { + return pulumix.Output[GetContextsResult]{ + OutputState: o.OutputState, + } +} + +func (o GetContextsResultOutput) Contexts() GetContextsContextArrayOutput { + return o.ApplyT(func(v GetContextsResult) []GetContextsContext { return v.Contexts }).(GetContextsContextArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetContextsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetContextsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Require contexts to have one of the labels +func (o GetContextsResultOutput) Labels() GetContextsLabelArrayOutput { + return o.ApplyT(func(v GetContextsResult) []GetContextsLabel { return v.Labels }).(GetContextsLabelArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetContextsResultOutput{}) +} diff --git a/sdk/go/spacelift/getCurrentSpace.go b/sdk/go/spacelift/getCurrentSpace.go new file mode 100644 index 0000000..a0b9227 --- /dev/null +++ b/sdk/go/spacelift/getCurrentSpace.go @@ -0,0 +1,102 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `getCurrentSpace` is a data source that provides information about the space that an administrative stack is in if the run is executed within Spacelift by a stack or module. This makes it easier to create resources within the same space. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// this, err := spacelift.GetCurrentSpace(ctx, nil, nil) +// if err != nil { +// return err +// } +// _, err = spacelift.NewContext(ctx, "prod-k8s-ie", &spacelift.ContextArgs{ +// Description: pulumi.String("Configuration details for the compute cluster in 🇮🇪"), +// SpaceId: *pulumi.String(this.Id), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetCurrentSpace(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetCurrentSpaceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetCurrentSpaceResult + err := ctx.Invoke("spacelift:index/getCurrentSpace:getCurrentSpace", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getCurrentSpace. +type GetCurrentSpaceResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` +} + +func GetCurrentSpaceOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetCurrentSpaceResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetCurrentSpaceResult, error) { + r, err := GetCurrentSpace(ctx, opts...) + var s GetCurrentSpaceResult + if r != nil { + s = *r + } + return s, err + }).(GetCurrentSpaceResultOutput) +} + +// A collection of values returned by getCurrentSpace. +type GetCurrentSpaceResultOutput struct{ *pulumi.OutputState } + +func (GetCurrentSpaceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCurrentSpaceResult)(nil)).Elem() +} + +func (o GetCurrentSpaceResultOutput) ToGetCurrentSpaceResultOutput() GetCurrentSpaceResultOutput { + return o +} + +func (o GetCurrentSpaceResultOutput) ToGetCurrentSpaceResultOutputWithContext(ctx context.Context) GetCurrentSpaceResultOutput { + return o +} + +func (o GetCurrentSpaceResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetCurrentSpaceResult] { + return pulumix.Output[GetCurrentSpaceResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCurrentSpaceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCurrentSpaceResult) string { return v.Id }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCurrentSpaceResultOutput{}) +} diff --git a/sdk/go/spacelift/getCurrentStack.go b/sdk/go/spacelift/getCurrentStack.go index 15c1bdd..c30b916 100644 --- a/sdk/go/spacelift/getCurrentStack.go +++ b/sdk/go/spacelift/getCurrentStack.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getCurrentStack` is a data source that provides information about the current administrative stack if the run is executed within Spacelift by a stack or module. This allows clever tricks like attaching contexts or policies to the stack that manages them. @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -28,7 +33,7 @@ import ( // return err // } // _, err = spacelift.NewEnvironmentVariable(ctx, "core-kubeconfig", &spacelift.EnvironmentVariableArgs{ -// StackId: pulumi.String(this.Id), +// StackId: *pulumi.String(this.Id), // Value: pulumi.String("bacon"), // }) // if err != nil { @@ -40,7 +45,7 @@ import ( // // ``` func GetCurrentStack(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetCurrentStackResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetCurrentStackResult err := ctx.Invoke("spacelift:index/getCurrentStack:getCurrentStack", nil, &rv, opts...) if err != nil { @@ -54,3 +59,44 @@ type GetCurrentStackResult struct { // The provider-assigned unique ID for this managed resource. Id string `pulumi:"id"` } + +func GetCurrentStackOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetCurrentStackResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetCurrentStackResult, error) { + r, err := GetCurrentStack(ctx, opts...) + var s GetCurrentStackResult + if r != nil { + s = *r + } + return s, err + }).(GetCurrentStackResultOutput) +} + +// A collection of values returned by getCurrentStack. +type GetCurrentStackResultOutput struct{ *pulumi.OutputState } + +func (GetCurrentStackResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCurrentStackResult)(nil)).Elem() +} + +func (o GetCurrentStackResultOutput) ToGetCurrentStackResultOutput() GetCurrentStackResultOutput { + return o +} + +func (o GetCurrentStackResultOutput) ToGetCurrentStackResultOutputWithContext(ctx context.Context) GetCurrentStackResultOutput { + return o +} + +func (o GetCurrentStackResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetCurrentStackResult] { + return pulumix.Output[GetCurrentStackResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCurrentStackResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCurrentStackResult) string { return v.Id }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCurrentStackResultOutput{}) +} diff --git a/sdk/go/spacelift/getDriftDetection.go b/sdk/go/spacelift/getDriftDetection.go index a18fe27..1746094 100644 --- a/sdk/go/spacelift/getDriftDetection.go +++ b/sdk/go/spacelift/getDriftDetection.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `DriftDetection` represents a Drift Detection configuration for a Stack. It will trigger a proposed run on the given schedule, which you can listen for using run state webhooks. If reconcile is true, then a tracked run will be triggered when drift is detected. @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupDriftDetection(ctx, &GetDriftDetectionArgs{ +// _, err := spacelift.LookupDriftDetection(ctx, &spacelift.LookupDriftDetectionArgs{ // StackId: "core-infra-production", // }, nil) // if err != nil { @@ -38,7 +40,7 @@ import ( // // ``` func LookupDriftDetection(ctx *pulumi.Context, args *LookupDriftDetectionArgs, opts ...pulumi.InvokeOption) (*LookupDriftDetectionResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupDriftDetectionResult err := ctx.Invoke("spacelift:index/getDriftDetection:getDriftDetection", args, &rv, opts...) if err != nil { @@ -49,6 +51,8 @@ func LookupDriftDetection(ctx *pulumi.Context, args *LookupDriftDetectionArgs, o // A collection of arguments for invoking getDriftDetection. type LookupDriftDetectionArgs struct { + // Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + IgnoreState *bool `pulumi:"ignoreState"` // ID of the stack for which to set up drift detection StackId string `pulumi:"stackId"` } @@ -57,6 +61,8 @@ type LookupDriftDetectionArgs struct { type LookupDriftDetectionResult struct { // The provider-assigned unique ID for this managed resource. Id string `pulumi:"id"` + // Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + IgnoreState *bool `pulumi:"ignoreState"` // Whether a tracked run should be triggered when drift is detected. Reconcile bool `pulumi:"reconcile"` // List of cron schedule expressions based on which drift detection should be triggered. @@ -82,6 +88,8 @@ func LookupDriftDetectionOutput(ctx *pulumi.Context, args LookupDriftDetectionOu // A collection of arguments for invoking getDriftDetection. type LookupDriftDetectionOutputArgs struct { + // Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + IgnoreState pulumi.BoolPtrInput `pulumi:"ignoreState"` // ID of the stack for which to set up drift detection StackId pulumi.StringInput `pulumi:"stackId"` } @@ -105,11 +113,22 @@ func (o LookupDriftDetectionResultOutput) ToLookupDriftDetectionResultOutputWith return o } +func (o LookupDriftDetectionResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupDriftDetectionResult] { + return pulumix.Output[LookupDriftDetectionResult]{ + OutputState: o.OutputState, + } +} + // The provider-assigned unique ID for this managed resource. func (o LookupDriftDetectionResultOutput) Id() pulumi.StringOutput { return o.ApplyT(func(v LookupDriftDetectionResult) string { return v.Id }).(pulumi.StringOutput) } +// Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. +func (o LookupDriftDetectionResultOutput) IgnoreState() pulumi.BoolPtrOutput { + return o.ApplyT(func(v LookupDriftDetectionResult) *bool { return v.IgnoreState }).(pulumi.BoolPtrOutput) +} + // Whether a tracked run should be triggered when drift is detected. func (o LookupDriftDetectionResultOutput) Reconcile() pulumi.BoolOutput { return o.ApplyT(func(v LookupDriftDetectionResult) bool { return v.Reconcile }).(pulumi.BoolOutput) diff --git a/sdk/go/spacelift/getEnvironmentVariable.go b/sdk/go/spacelift/getEnvironmentVariable.go index c4efbba..385ef79 100644 --- a/sdk/go/spacelift/getEnvironmentVariable.go +++ b/sdk/go/spacelift/getEnvironmentVariable.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `EnvironmentVariable` defines an environment variable on the context (`Context`), stack (`Stack`) or a module (`Module`), thereby allowing to pass and share various secrets and configuration with Spacelift stacks. @@ -20,27 +22,27 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupEnvironmentVariable(ctx, &GetEnvironmentVariableArgs{ +// _, err := spacelift.LookupEnvironmentVariable(ctx, &spacelift.LookupEnvironmentVariableArgs{ // ContextId: pulumi.StringRef("prod-k8s-ie"), // Name: "KUBECONFIG", // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupEnvironmentVariable(ctx, &GetEnvironmentVariableArgs{ +// _, err = spacelift.LookupEnvironmentVariable(ctx, &spacelift.LookupEnvironmentVariableArgs{ // ModuleId: pulumi.StringRef("k8s-module"), // Name: "KUBECONFIG", // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupEnvironmentVariable(ctx, &GetEnvironmentVariableArgs{ +// _, err = spacelift.LookupEnvironmentVariable(ctx, &spacelift.LookupEnvironmentVariableArgs{ // Name: "KUBECONFIG", // StackId: pulumi.StringRef("k8s-core"), // }, nil) @@ -53,7 +55,7 @@ import ( // // ``` func LookupEnvironmentVariable(ctx *pulumi.Context, args *LookupEnvironmentVariableArgs, opts ...pulumi.InvokeOption) (*LookupEnvironmentVariableResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupEnvironmentVariableResult err := ctx.Invoke("spacelift:index/getEnvironmentVariable:getEnvironmentVariable", args, &rv, opts...) if err != nil { @@ -138,6 +140,12 @@ func (o LookupEnvironmentVariableResultOutput) ToLookupEnvironmentVariableResult return o } +func (o LookupEnvironmentVariableResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupEnvironmentVariableResult] { + return pulumix.Output[LookupEnvironmentVariableResult]{ + OutputState: o.OutputState, + } +} + // SHA-256 checksum of the value func (o LookupEnvironmentVariableResultOutput) Checksum() pulumi.StringOutput { return o.ApplyT(func(v LookupEnvironmentVariableResult) string { return v.Checksum }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getGcpServiceAccount.go b/sdk/go/spacelift/getGcpServiceAccount.go index 9976481..dbbacd4 100644 --- a/sdk/go/spacelift/getGcpServiceAccount.go +++ b/sdk/go/spacelift/getGcpServiceAccount.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // ## Example Usage @@ -18,19 +20,19 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupGcpServiceAccount(ctx, &GetGcpServiceAccountArgs{ +// _, err := spacelift.LookupGcpServiceAccount(ctx, &spacelift.LookupGcpServiceAccountArgs{ // ModuleId: pulumi.StringRef("k8s-module"), // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupGcpServiceAccount(ctx, &GetGcpServiceAccountArgs{ +// _, err = spacelift.LookupGcpServiceAccount(ctx, &spacelift.LookupGcpServiceAccountArgs{ // StackId: pulumi.StringRef("k8s-core"), // }, nil) // if err != nil { @@ -42,7 +44,7 @@ import ( // // ``` func LookupGcpServiceAccount(ctx *pulumi.Context, args *LookupGcpServiceAccountArgs, opts ...pulumi.InvokeOption) (*LookupGcpServiceAccountResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupGcpServiceAccountResult err := ctx.Invoke("spacelift:index/getGcpServiceAccount:getGcpServiceAccount", args, &rv, opts...) if err != nil { @@ -113,6 +115,12 @@ func (o LookupGcpServiceAccountResultOutput) ToLookupGcpServiceAccountResultOutp return o } +func (o LookupGcpServiceAccountResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupGcpServiceAccountResult] { + return pulumix.Output[LookupGcpServiceAccountResult]{ + OutputState: o.OutputState, + } +} + // The provider-assigned unique ID for this managed resource. func (o LookupGcpServiceAccountResultOutput) Id() pulumi.StringOutput { return o.ApplyT(func(v LookupGcpServiceAccountResult) string { return v.Id }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getGithubEnterpriseIntegration.go b/sdk/go/spacelift/getGithubEnterpriseIntegration.go index 8573f4b..5954fe7 100644 --- a/sdk/go/spacelift/getGithubEnterpriseIntegration.go +++ b/sdk/go/spacelift/getGithubEnterpriseIntegration.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getGithubEnterpriseIntegration` returns details about Github Enterprise integration @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetGithubEnterpriseIntegration(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetGithubEnterpriseIntegrationResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetGithubEnterpriseIntegrationResult err := ctx.Invoke("spacelift:index/getGithubEnterpriseIntegration:getGithubEnterpriseIntegration", nil, &rv, opts...) if err != nil { @@ -53,3 +58,59 @@ type GetGithubEnterpriseIntegrationResult struct { // Github integration webhook secret WebhookSecret string `pulumi:"webhookSecret"` } + +func GetGithubEnterpriseIntegrationOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetGithubEnterpriseIntegrationResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetGithubEnterpriseIntegrationResult, error) { + r, err := GetGithubEnterpriseIntegration(ctx, opts...) + var s GetGithubEnterpriseIntegrationResult + if r != nil { + s = *r + } + return s, err + }).(GetGithubEnterpriseIntegrationResultOutput) +} + +// A collection of values returned by getGithubEnterpriseIntegration. +type GetGithubEnterpriseIntegrationResultOutput struct{ *pulumi.OutputState } + +func (GetGithubEnterpriseIntegrationResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetGithubEnterpriseIntegrationResult)(nil)).Elem() +} + +func (o GetGithubEnterpriseIntegrationResultOutput) ToGetGithubEnterpriseIntegrationResultOutput() GetGithubEnterpriseIntegrationResultOutput { + return o +} + +func (o GetGithubEnterpriseIntegrationResultOutput) ToGetGithubEnterpriseIntegrationResultOutputWithContext(ctx context.Context) GetGithubEnterpriseIntegrationResultOutput { + return o +} + +func (o GetGithubEnterpriseIntegrationResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetGithubEnterpriseIntegrationResult] { + return pulumix.Output[GetGithubEnterpriseIntegrationResult]{ + OutputState: o.OutputState, + } +} + +// Github integration api host +func (o GetGithubEnterpriseIntegrationResultOutput) ApiHost() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubEnterpriseIntegrationResult) string { return v.ApiHost }).(pulumi.StringOutput) +} + +// Github integration app id +func (o GetGithubEnterpriseIntegrationResultOutput) AppId() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubEnterpriseIntegrationResult) string { return v.AppId }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetGithubEnterpriseIntegrationResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubEnterpriseIntegrationResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Github integration webhook secret +func (o GetGithubEnterpriseIntegrationResultOutput) WebhookSecret() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubEnterpriseIntegrationResult) string { return v.WebhookSecret }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetGithubEnterpriseIntegrationResultOutput{}) +} diff --git a/sdk/go/spacelift/getGitlabIntegration.go b/sdk/go/spacelift/getGitlabIntegration.go index 657fea5..892dc17 100644 --- a/sdk/go/spacelift/getGitlabIntegration.go +++ b/sdk/go/spacelift/getGitlabIntegration.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getGitlabIntegration` returns details about Gitlab integration @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetGitlabIntegration(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetGitlabIntegrationResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetGitlabIntegrationResult err := ctx.Invoke("spacelift:index/getGitlabIntegration:getGitlabIntegration", nil, &rv, opts...) if err != nil { @@ -51,3 +56,54 @@ type GetGitlabIntegrationResult struct { // Gitlab integration webhook secret WebhookSecret string `pulumi:"webhookSecret"` } + +func GetGitlabIntegrationOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetGitlabIntegrationResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetGitlabIntegrationResult, error) { + r, err := GetGitlabIntegration(ctx, opts...) + var s GetGitlabIntegrationResult + if r != nil { + s = *r + } + return s, err + }).(GetGitlabIntegrationResultOutput) +} + +// A collection of values returned by getGitlabIntegration. +type GetGitlabIntegrationResultOutput struct{ *pulumi.OutputState } + +func (GetGitlabIntegrationResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetGitlabIntegrationResult)(nil)).Elem() +} + +func (o GetGitlabIntegrationResultOutput) ToGetGitlabIntegrationResultOutput() GetGitlabIntegrationResultOutput { + return o +} + +func (o GetGitlabIntegrationResultOutput) ToGetGitlabIntegrationResultOutputWithContext(ctx context.Context) GetGitlabIntegrationResultOutput { + return o +} + +func (o GetGitlabIntegrationResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetGitlabIntegrationResult] { + return pulumix.Output[GetGitlabIntegrationResult]{ + OutputState: o.OutputState, + } +} + +// Gitlab integration api host +func (o GetGitlabIntegrationResultOutput) ApiHost() pulumi.StringOutput { + return o.ApplyT(func(v GetGitlabIntegrationResult) string { return v.ApiHost }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetGitlabIntegrationResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetGitlabIntegrationResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Gitlab integration webhook secret +func (o GetGitlabIntegrationResultOutput) WebhookSecret() pulumi.StringOutput { + return o.ApplyT(func(v GetGitlabIntegrationResult) string { return v.WebhookSecret }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetGitlabIntegrationResultOutput{}) +} diff --git a/sdk/go/spacelift/getGitlabWebhookEndpoint.go b/sdk/go/spacelift/getGitlabWebhookEndpoint.go new file mode 100644 index 0000000..58ca18f --- /dev/null +++ b/sdk/go/spacelift/getGitlabWebhookEndpoint.go @@ -0,0 +1,102 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `getGitlabWebhookEndpoint` returns details about Gitlab webhook endpoint +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := spacelift.GetGitlabWebhookEndpoint(ctx, nil, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetGitlabWebhookEndpoint(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetGitlabWebhookEndpointResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetGitlabWebhookEndpointResult + err := ctx.Invoke("spacelift:index/getGitlabWebhookEndpoint:getGitlabWebhookEndpoint", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getGitlabWebhookEndpoint. +type GetGitlabWebhookEndpointResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Gitlab webhook endpoint address + WebhookEndpoint string `pulumi:"webhookEndpoint"` +} + +func GetGitlabWebhookEndpointOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetGitlabWebhookEndpointResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetGitlabWebhookEndpointResult, error) { + r, err := GetGitlabWebhookEndpoint(ctx, opts...) + var s GetGitlabWebhookEndpointResult + if r != nil { + s = *r + } + return s, err + }).(GetGitlabWebhookEndpointResultOutput) +} + +// A collection of values returned by getGitlabWebhookEndpoint. +type GetGitlabWebhookEndpointResultOutput struct{ *pulumi.OutputState } + +func (GetGitlabWebhookEndpointResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetGitlabWebhookEndpointResult)(nil)).Elem() +} + +func (o GetGitlabWebhookEndpointResultOutput) ToGetGitlabWebhookEndpointResultOutput() GetGitlabWebhookEndpointResultOutput { + return o +} + +func (o GetGitlabWebhookEndpointResultOutput) ToGetGitlabWebhookEndpointResultOutputWithContext(ctx context.Context) GetGitlabWebhookEndpointResultOutput { + return o +} + +func (o GetGitlabWebhookEndpointResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetGitlabWebhookEndpointResult] { + return pulumix.Output[GetGitlabWebhookEndpointResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetGitlabWebhookEndpointResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetGitlabWebhookEndpointResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Gitlab webhook endpoint address +func (o GetGitlabWebhookEndpointResultOutput) WebhookEndpoint() pulumi.StringOutput { + return o.ApplyT(func(v GetGitlabWebhookEndpointResult) string { return v.WebhookEndpoint }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetGitlabWebhookEndpointResultOutput{}) +} diff --git a/sdk/go/spacelift/getIPs.go b/sdk/go/spacelift/getIPs.go index abce7ea..1e26af1 100644 --- a/sdk/go/spacelift/getIPs.go +++ b/sdk/go/spacelift/getIPs.go @@ -4,10 +4,15 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) -// `getIPs` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". +// `getIPs` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". **NOTE:** this does not include the IP addresses of the workers in Spacelift's public worker pool. If you need to ensure that requests made during runs originate from a known set of IP addresses, please consider setting up a [private worker pool](https://docs.spacelift.io/concepts/worker-pools). // // ## Example Usage // @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetIPs(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetIPsResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetIPsResult err := ctx.Invoke("spacelift:index/getIPs:getIPs", nil, &rv, opts...) if err != nil { @@ -49,3 +54,49 @@ type GetIPsResult struct { // the list of spacelift.io outgoing IP addresses Ips []string `pulumi:"ips"` } + +func GetIPsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetIPsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetIPsResult, error) { + r, err := GetIPs(ctx, opts...) + var s GetIPsResult + if r != nil { + s = *r + } + return s, err + }).(GetIPsResultOutput) +} + +// A collection of values returned by getIPs. +type GetIPsResultOutput struct{ *pulumi.OutputState } + +func (GetIPsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetIPsResult)(nil)).Elem() +} + +func (o GetIPsResultOutput) ToGetIPsResultOutput() GetIPsResultOutput { + return o +} + +func (o GetIPsResultOutput) ToGetIPsResultOutputWithContext(ctx context.Context) GetIPsResultOutput { + return o +} + +func (o GetIPsResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetIPsResult] { + return pulumix.Output[GetIPsResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetIPsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetIPsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// the list of spacelift.io outgoing IP addresses +func (o GetIPsResultOutput) Ips() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIPsResult) []string { return v.Ips }).(pulumi.StringArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetIPsResultOutput{}) +} diff --git a/sdk/go/spacelift/getModule.go b/sdk/go/spacelift/getModule.go index c8785ea..50876d4 100644 --- a/sdk/go/spacelift/getModule.go +++ b/sdk/go/spacelift/getModule.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // ## Example Usage @@ -18,13 +20,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupModule(ctx, &GetModuleArgs{ +// _, err := spacelift.LookupModule(ctx, &spacelift.LookupModuleArgs{ // ModuleId: "k8s-module", // }, nil) // if err != nil { @@ -36,7 +38,7 @@ import ( // // ``` func LookupModule(ctx *pulumi.Context, args *LookupModuleArgs, opts ...pulumi.InvokeOption) (*LookupModuleResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupModuleResult err := ctx.Invoke("spacelift:index/getModule:getModule", args, &rv, opts...) if err != nil { @@ -67,6 +69,8 @@ type LookupModuleResult struct { Branch string `pulumi:"branch"` // free-form module description for human users (supports Markdown) Description string `pulumi:"description"` + // Indicates whether local preview versions can be triggered on this Module. + EnableLocalPreview bool `pulumi:"enableLocalPreview"` // GitHub Enterprise (self-hosted) VCS settings GithubEnterprises []GetModuleGithubEnterprise `pulumi:"githubEnterprises"` // GitLab VCS settings @@ -90,6 +94,8 @@ type LookupModuleResult struct { TerraformProvider string `pulumi:"terraformProvider"` // ID of the worker pool to use WorkerPoolId string `pulumi:"workerPoolId"` + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. + WorkflowTool string `pulumi:"workflowTool"` } func LookupModuleOutput(ctx *pulumi.Context, args LookupModuleOutputArgs, opts ...pulumi.InvokeOption) LookupModuleResultOutput { @@ -130,6 +136,12 @@ func (o LookupModuleResultOutput) ToLookupModuleResultOutputWithContext(ctx cont return o } +func (o LookupModuleResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupModuleResult] { + return pulumix.Output[LookupModuleResult]{ + OutputState: o.OutputState, + } +} + // indicates whether this module can administer others func (o LookupModuleResultOutput) Administrative() pulumi.BoolOutput { return o.ApplyT(func(v LookupModuleResult) bool { return v.Administrative }).(pulumi.BoolOutput) @@ -165,6 +177,11 @@ func (o LookupModuleResultOutput) Description() pulumi.StringOutput { return o.ApplyT(func(v LookupModuleResult) string { return v.Description }).(pulumi.StringOutput) } +// Indicates whether local preview versions can be triggered on this Module. +func (o LookupModuleResultOutput) EnableLocalPreview() pulumi.BoolOutput { + return o.ApplyT(func(v LookupModuleResult) bool { return v.EnableLocalPreview }).(pulumi.BoolOutput) +} + // GitHub Enterprise (self-hosted) VCS settings func (o LookupModuleResultOutput) GithubEnterprises() GetModuleGithubEnterpriseArrayOutput { return o.ApplyT(func(v LookupModuleResult) []GetModuleGithubEnterprise { return v.GithubEnterprises }).(GetModuleGithubEnterpriseArrayOutput) @@ -227,6 +244,11 @@ func (o LookupModuleResultOutput) WorkerPoolId() pulumi.StringOutput { return o.ApplyT(func(v LookupModuleResult) string { return v.WorkerPoolId }).(pulumi.StringOutput) } +// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. +func (o LookupModuleResultOutput) WorkflowTool() pulumi.StringOutput { + return o.ApplyT(func(v LookupModuleResult) string { return v.WorkflowTool }).(pulumi.StringOutput) +} + func init() { pulumi.RegisterOutputType(LookupModuleResultOutput{}) } diff --git a/sdk/go/spacelift/getMountedfile.go b/sdk/go/spacelift/getMountedfile.go index 79eb7f5..b4b0bb1 100644 --- a/sdk/go/spacelift/getMountedfile.go +++ b/sdk/go/spacelift/getMountedfile.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Mountedfile` represents a file mounted in each Run's workspace that is part of a configuration of a context (`Context`), stack (`Stack`) or a module (`Module`). In principle, it's very similar to an environment variable (`EnvironmentVariable`) except that the value is written to the filesystem rather than passed to the environment. @@ -20,27 +22,27 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupMountedfile(ctx, &GetMountedfileArgs{ +// _, err := spacelift.LookupMountedfile(ctx, &spacelift.LookupMountedfileArgs{ // ContextId: pulumi.StringRef("prod-k8s-ie"), // RelativePath: "kubeconfig", // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupMountedfile(ctx, &GetMountedfileArgs{ +// _, err = spacelift.LookupMountedfile(ctx, &spacelift.LookupMountedfileArgs{ // ModuleId: pulumi.StringRef("k8s-module"), // RelativePath: "kubeconfig", // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupMountedfile(ctx, &GetMountedfileArgs{ +// _, err = spacelift.LookupMountedfile(ctx, &spacelift.LookupMountedfileArgs{ // RelativePath: "kubeconfig", // StackId: pulumi.StringRef("k8s-core"), // }, nil) @@ -53,7 +55,7 @@ import ( // // ``` func LookupMountedfile(ctx *pulumi.Context, args *LookupMountedfileArgs, opts ...pulumi.InvokeOption) (*LookupMountedfileResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupMountedfileResult err := ctx.Invoke("spacelift:index/getMountedfile:getMountedfile", args, &rv, opts...) if err != nil { @@ -138,6 +140,12 @@ func (o LookupMountedfileResultOutput) ToLookupMountedfileResultOutputWithContex return o } +func (o LookupMountedfileResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupMountedfileResult] { + return pulumix.Output[LookupMountedfileResult]{ + OutputState: o.OutputState, + } +} + // SHA-256 checksum of the value func (o LookupMountedfileResultOutput) Checksum() pulumi.StringOutput { return o.ApplyT(func(v LookupMountedfileResult) string { return v.Checksum }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getNamedWebhook.go b/sdk/go/spacelift/getNamedWebhook.go new file mode 100644 index 0000000..2277204 --- /dev/null +++ b/sdk/go/spacelift/getNamedWebhook.go @@ -0,0 +1,145 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. +func LookupNamedWebhook(ctx *pulumi.Context, args *LookupNamedWebhookArgs, opts ...pulumi.InvokeOption) (*LookupNamedWebhookResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupNamedWebhookResult + err := ctx.Invoke("spacelift:index/getNamedWebhook:getNamedWebhook", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getNamedWebhook. +type LookupNamedWebhookArgs struct { + // ID of the webhook + WebhookId string `pulumi:"webhookId"` +} + +// A collection of values returned by getNamedWebhook. +type LookupNamedWebhookResult struct { + // enables or disables sending webhooks. + Enabled bool `pulumi:"enabled"` + // endpoint to send the requests to + Endpoint string `pulumi:"endpoint"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // labels for the webhook to use when referring in policies or filtering them + Labels []string `pulumi:"labels"` + // the name for the webhook which will also be used to generate the id + Name string `pulumi:"name"` + // secret used to sign each request so you're able to verify that the request comes from us. + Secret string `pulumi:"secret"` + // secret header keys which are currently set for this webhook + SecretHeaderKeys []string `pulumi:"secretHeaderKeys"` + // ID of the space the webhook is in + SpaceId string `pulumi:"spaceId"` + // ID of the webhook + WebhookId string `pulumi:"webhookId"` +} + +func LookupNamedWebhookOutput(ctx *pulumi.Context, args LookupNamedWebhookOutputArgs, opts ...pulumi.InvokeOption) LookupNamedWebhookResultOutput { + return pulumi.ToOutputWithContext(context.Background(), args). + ApplyT(func(v interface{}) (LookupNamedWebhookResult, error) { + args := v.(LookupNamedWebhookArgs) + r, err := LookupNamedWebhook(ctx, &args, opts...) + var s LookupNamedWebhookResult + if r != nil { + s = *r + } + return s, err + }).(LookupNamedWebhookResultOutput) +} + +// A collection of arguments for invoking getNamedWebhook. +type LookupNamedWebhookOutputArgs struct { + // ID of the webhook + WebhookId pulumi.StringInput `pulumi:"webhookId"` +} + +func (LookupNamedWebhookOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNamedWebhookArgs)(nil)).Elem() +} + +// A collection of values returned by getNamedWebhook. +type LookupNamedWebhookResultOutput struct{ *pulumi.OutputState } + +func (LookupNamedWebhookResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNamedWebhookResult)(nil)).Elem() +} + +func (o LookupNamedWebhookResultOutput) ToLookupNamedWebhookResultOutput() LookupNamedWebhookResultOutput { + return o +} + +func (o LookupNamedWebhookResultOutput) ToLookupNamedWebhookResultOutputWithContext(ctx context.Context) LookupNamedWebhookResultOutput { + return o +} + +func (o LookupNamedWebhookResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupNamedWebhookResult] { + return pulumix.Output[LookupNamedWebhookResult]{ + OutputState: o.OutputState, + } +} + +// enables or disables sending webhooks. +func (o LookupNamedWebhookResultOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +// endpoint to send the requests to +func (o LookupNamedWebhookResultOutput) Endpoint() pulumi.StringOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) string { return v.Endpoint }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupNamedWebhookResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) string { return v.Id }).(pulumi.StringOutput) +} + +// labels for the webhook to use when referring in policies or filtering them +func (o LookupNamedWebhookResultOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +// the name for the webhook which will also be used to generate the id +func (o LookupNamedWebhookResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) string { return v.Name }).(pulumi.StringOutput) +} + +// secret used to sign each request so you're able to verify that the request comes from us. +func (o LookupNamedWebhookResultOutput) Secret() pulumi.StringOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) string { return v.Secret }).(pulumi.StringOutput) +} + +// secret header keys which are currently set for this webhook +func (o LookupNamedWebhookResultOutput) SecretHeaderKeys() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) []string { return v.SecretHeaderKeys }).(pulumi.StringArrayOutput) +} + +// ID of the space the webhook is in +func (o LookupNamedWebhookResultOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) string { return v.SpaceId }).(pulumi.StringOutput) +} + +// ID of the webhook +func (o LookupNamedWebhookResultOutput) WebhookId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNamedWebhookResult) string { return v.WebhookId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupNamedWebhookResultOutput{}) +} diff --git a/sdk/go/spacelift/getPolicies.go b/sdk/go/spacelift/getPolicies.go index 6aeaf82..09964f2 100644 --- a/sdk/go/spacelift/getPolicies.go +++ b/sdk/go/spacelift/getPolicies.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getPolicies` can find all policies that have certain labels. @@ -20,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -30,7 +32,7 @@ import ( // if err != nil { // return err // } -// _, err = spacelift.GetPolicies(ctx, &GetPoliciesArgs{ +// _, err = spacelift.GetPolicies(ctx, &spacelift.GetPoliciesArgs{ // Type: pulumi.StringRef("PLAN"), // Labels: []string{ // "autoattach", @@ -50,7 +52,7 @@ import ( // // ``` func GetPolicies(ctx *pulumi.Context, args *GetPoliciesArgs, opts ...pulumi.InvokeOption) (*GetPoliciesResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetPoliciesResult err := ctx.Invoke("spacelift:index/getPolicies:getPolicies", args, &rv, opts...) if err != nil { @@ -61,10 +63,8 @@ func GetPolicies(ctx *pulumi.Context, args *GetPoliciesArgs, opts ...pulumi.Invo // A collection of arguments for invoking getPolicies. type GetPoliciesArgs struct { - // required labels to match Labels []string `pulumi:"labels"` - // required policy type - Type *string `pulumi:"type"` + Type *string `pulumi:"type"` } // A collection of values returned by getPolicies. @@ -93,10 +93,8 @@ func GetPoliciesOutput(ctx *pulumi.Context, args GetPoliciesOutputArgs, opts ... // A collection of arguments for invoking getPolicies. type GetPoliciesOutputArgs struct { - // required labels to match Labels pulumi.StringArrayInput `pulumi:"labels"` - // required policy type - Type pulumi.StringPtrInput `pulumi:"type"` + Type pulumi.StringPtrInput `pulumi:"type"` } func (GetPoliciesOutputArgs) ElementType() reflect.Type { @@ -118,6 +116,12 @@ func (o GetPoliciesResultOutput) ToGetPoliciesResultOutputWithContext(ctx contex return o } +func (o GetPoliciesResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetPoliciesResult] { + return pulumix.Output[GetPoliciesResult]{ + OutputState: o.OutputState, + } +} + // The provider-assigned unique ID for this managed resource. func (o GetPoliciesResultOutput) Id() pulumi.StringOutput { return o.ApplyT(func(v GetPoliciesResult) string { return v.Id }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getPolicy.go b/sdk/go/spacelift/getPolicy.go index 39c3dbb..742c7be 100644 --- a/sdk/go/spacelift/getPolicy.go +++ b/sdk/go/spacelift/getPolicy.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Policy` represents a Spacelift **policy** - a collection of customer-defined rules that are applied by Spacelift at one of the decision points within the application. @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// policy, err := spacelift.LookupPolicy(ctx, &GetPolicyArgs{ +// policy, err := spacelift.LookupPolicy(ctx, &spacelift.LookupPolicyArgs{ // PolicyId: spacelift_policy.Policy.Id, // }, nil) // if err != nil { @@ -39,7 +41,7 @@ import ( // // ``` func LookupPolicy(ctx *pulumi.Context, args *LookupPolicyArgs, opts ...pulumi.InvokeOption) (*LookupPolicyResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupPolicyResult err := ctx.Invoke("spacelift:index/getPolicy:getPolicy", args, &rv, opts...) if err != nil { @@ -109,6 +111,12 @@ func (o LookupPolicyResultOutput) ToLookupPolicyResultOutputWithContext(ctx cont return o } +func (o LookupPolicyResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupPolicyResult] { + return pulumix.Output[LookupPolicyResult]{ + OutputState: o.OutputState, + } +} + // body of the policy func (o LookupPolicyResultOutput) Body() pulumi.StringOutput { return o.ApplyT(func(v LookupPolicyResult) string { return v.Body }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getScheduledDeleteStack.go b/sdk/go/spacelift/getScheduledDeleteStack.go new file mode 100644 index 0000000..a8023ea --- /dev/null +++ b/sdk/go/spacelift/getScheduledDeleteStack.go @@ -0,0 +1,150 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := spacelift.GetScheduledDeleteStack(ctx, &spacelift.GetScheduledDeleteStackArgs{ +// ScheduledDeleteStackId: "$STACK_ID/$SCHEDULED_DELETE_STACK_ID", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetScheduledDeleteStack(ctx *pulumi.Context, args *GetScheduledDeleteStackArgs, opts ...pulumi.InvokeOption) (*GetScheduledDeleteStackResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetScheduledDeleteStackResult + err := ctx.Invoke("spacelift:index/getScheduledDeleteStack:getScheduledDeleteStack", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getScheduledDeleteStack. +type GetScheduledDeleteStackArgs struct { + // ID of the scheduled delete*stack (stack*id/schedule_id) + ScheduledDeleteStackId string `pulumi:"scheduledDeleteStackId"` +} + +// A collection of values returned by getScheduledDeleteStack. +type GetScheduledDeleteStackResult struct { + // Timestamp (unix timestamp) at which time the scheduling should happen. + At int `pulumi:"at"` + // Indicates whether the resources of the stack should be deleted. + DeleteResources bool `pulumi:"deleteResources"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // ID of the schedule + ScheduleId string `pulumi:"scheduleId"` + // ID of the scheduled delete*stack (stack*id/schedule_id) + ScheduledDeleteStackId string `pulumi:"scheduledDeleteStackId"` + // Stack ID of the scheduling config + StackId string `pulumi:"stackId"` +} + +func GetScheduledDeleteStackOutput(ctx *pulumi.Context, args GetScheduledDeleteStackOutputArgs, opts ...pulumi.InvokeOption) GetScheduledDeleteStackResultOutput { + return pulumi.ToOutputWithContext(context.Background(), args). + ApplyT(func(v interface{}) (GetScheduledDeleteStackResult, error) { + args := v.(GetScheduledDeleteStackArgs) + r, err := GetScheduledDeleteStack(ctx, &args, opts...) + var s GetScheduledDeleteStackResult + if r != nil { + s = *r + } + return s, err + }).(GetScheduledDeleteStackResultOutput) +} + +// A collection of arguments for invoking getScheduledDeleteStack. +type GetScheduledDeleteStackOutputArgs struct { + // ID of the scheduled delete*stack (stack*id/schedule_id) + ScheduledDeleteStackId pulumi.StringInput `pulumi:"scheduledDeleteStackId"` +} + +func (GetScheduledDeleteStackOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetScheduledDeleteStackArgs)(nil)).Elem() +} + +// A collection of values returned by getScheduledDeleteStack. +type GetScheduledDeleteStackResultOutput struct{ *pulumi.OutputState } + +func (GetScheduledDeleteStackResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetScheduledDeleteStackResult)(nil)).Elem() +} + +func (o GetScheduledDeleteStackResultOutput) ToGetScheduledDeleteStackResultOutput() GetScheduledDeleteStackResultOutput { + return o +} + +func (o GetScheduledDeleteStackResultOutput) ToGetScheduledDeleteStackResultOutputWithContext(ctx context.Context) GetScheduledDeleteStackResultOutput { + return o +} + +func (o GetScheduledDeleteStackResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetScheduledDeleteStackResult] { + return pulumix.Output[GetScheduledDeleteStackResult]{ + OutputState: o.OutputState, + } +} + +// Timestamp (unix timestamp) at which time the scheduling should happen. +func (o GetScheduledDeleteStackResultOutput) At() pulumi.IntOutput { + return o.ApplyT(func(v GetScheduledDeleteStackResult) int { return v.At }).(pulumi.IntOutput) +} + +// Indicates whether the resources of the stack should be deleted. +func (o GetScheduledDeleteStackResultOutput) DeleteResources() pulumi.BoolOutput { + return o.ApplyT(func(v GetScheduledDeleteStackResult) bool { return v.DeleteResources }).(pulumi.BoolOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetScheduledDeleteStackResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetScheduledDeleteStackResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the schedule +func (o GetScheduledDeleteStackResultOutput) ScheduleId() pulumi.StringOutput { + return o.ApplyT(func(v GetScheduledDeleteStackResult) string { return v.ScheduleId }).(pulumi.StringOutput) +} + +// ID of the scheduled delete*stack (stack*id/schedule_id) +func (o GetScheduledDeleteStackResultOutput) ScheduledDeleteStackId() pulumi.StringOutput { + return o.ApplyT(func(v GetScheduledDeleteStackResult) string { return v.ScheduledDeleteStackId }).(pulumi.StringOutput) +} + +// Stack ID of the scheduling config +func (o GetScheduledDeleteStackResultOutput) StackId() pulumi.StringOutput { + return o.ApplyT(func(v GetScheduledDeleteStackResult) string { return v.StackId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetScheduledDeleteStackResultOutput{}) +} diff --git a/sdk/go/spacelift/getScheduledTask.go b/sdk/go/spacelift/getScheduledTask.go new file mode 100644 index 0000000..4d7b081 --- /dev/null +++ b/sdk/go/spacelift/getScheduledTask.go @@ -0,0 +1,164 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `ScheduledTask` represents a scheduling configuration for a Stack. It will trigger a task on the given timestamp/schedule. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := spacelift.LookupScheduledTask(ctx, &spacelift.LookupScheduledTaskArgs{ +// ScheduledTaskId: "$STACK_ID/$SCHEDULED_TASK_ID", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupScheduledTask(ctx *pulumi.Context, args *LookupScheduledTaskArgs, opts ...pulumi.InvokeOption) (*LookupScheduledTaskResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupScheduledTaskResult + err := ctx.Invoke("spacelift:index/getScheduledTask:getScheduledTask", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getScheduledTask. +type LookupScheduledTaskArgs struct { + // ID of the scheduled task (stack*id/schedule*id) + ScheduledTaskId string `pulumi:"scheduledTaskId"` +} + +// A collection of values returned by getScheduledTask. +type LookupScheduledTaskResult struct { + // Timestamp (unix timestamp) at which time the scheduling should happen. + At int `pulumi:"at"` + // Command that will be run. + Command string `pulumi:"command"` + // List of cron schedule expressions based on which the scheduled task should be triggered. + Everies []string `pulumi:"everies"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // ID of the schedule + ScheduleId string `pulumi:"scheduleId"` + // ID of the scheduled task (stack*id/schedule*id) + ScheduledTaskId string `pulumi:"scheduledTaskId"` + // Stack ID of the scheduled task + StackId string `pulumi:"stackId"` + // Timezone in which the schedule is expressed. Defaults to `UTC`. + Timezone string `pulumi:"timezone"` +} + +func LookupScheduledTaskOutput(ctx *pulumi.Context, args LookupScheduledTaskOutputArgs, opts ...pulumi.InvokeOption) LookupScheduledTaskResultOutput { + return pulumi.ToOutputWithContext(context.Background(), args). + ApplyT(func(v interface{}) (LookupScheduledTaskResult, error) { + args := v.(LookupScheduledTaskArgs) + r, err := LookupScheduledTask(ctx, &args, opts...) + var s LookupScheduledTaskResult + if r != nil { + s = *r + } + return s, err + }).(LookupScheduledTaskResultOutput) +} + +// A collection of arguments for invoking getScheduledTask. +type LookupScheduledTaskOutputArgs struct { + // ID of the scheduled task (stack*id/schedule*id) + ScheduledTaskId pulumi.StringInput `pulumi:"scheduledTaskId"` +} + +func (LookupScheduledTaskOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupScheduledTaskArgs)(nil)).Elem() +} + +// A collection of values returned by getScheduledTask. +type LookupScheduledTaskResultOutput struct{ *pulumi.OutputState } + +func (LookupScheduledTaskResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupScheduledTaskResult)(nil)).Elem() +} + +func (o LookupScheduledTaskResultOutput) ToLookupScheduledTaskResultOutput() LookupScheduledTaskResultOutput { + return o +} + +func (o LookupScheduledTaskResultOutput) ToLookupScheduledTaskResultOutputWithContext(ctx context.Context) LookupScheduledTaskResultOutput { + return o +} + +func (o LookupScheduledTaskResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupScheduledTaskResult] { + return pulumix.Output[LookupScheduledTaskResult]{ + OutputState: o.OutputState, + } +} + +// Timestamp (unix timestamp) at which time the scheduling should happen. +func (o LookupScheduledTaskResultOutput) At() pulumi.IntOutput { + return o.ApplyT(func(v LookupScheduledTaskResult) int { return v.At }).(pulumi.IntOutput) +} + +// Command that will be run. +func (o LookupScheduledTaskResultOutput) Command() pulumi.StringOutput { + return o.ApplyT(func(v LookupScheduledTaskResult) string { return v.Command }).(pulumi.StringOutput) +} + +// List of cron schedule expressions based on which the scheduled task should be triggered. +func (o LookupScheduledTaskResultOutput) Everies() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupScheduledTaskResult) []string { return v.Everies }).(pulumi.StringArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupScheduledTaskResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupScheduledTaskResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the schedule +func (o LookupScheduledTaskResultOutput) ScheduleId() pulumi.StringOutput { + return o.ApplyT(func(v LookupScheduledTaskResult) string { return v.ScheduleId }).(pulumi.StringOutput) +} + +// ID of the scheduled task (stack*id/schedule*id) +func (o LookupScheduledTaskResultOutput) ScheduledTaskId() pulumi.StringOutput { + return o.ApplyT(func(v LookupScheduledTaskResult) string { return v.ScheduledTaskId }).(pulumi.StringOutput) +} + +// Stack ID of the scheduled task +func (o LookupScheduledTaskResultOutput) StackId() pulumi.StringOutput { + return o.ApplyT(func(v LookupScheduledTaskResult) string { return v.StackId }).(pulumi.StringOutput) +} + +// Timezone in which the schedule is expressed. Defaults to `UTC`. +func (o LookupScheduledTaskResultOutput) Timezone() pulumi.StringOutput { + return o.ApplyT(func(v LookupScheduledTaskResult) string { return v.Timezone }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupScheduledTaskResultOutput{}) +} diff --git a/sdk/go/spacelift/getSpace.go b/sdk/go/spacelift/getSpace.go index 24384de..b02ba62 100644 --- a/sdk/go/spacelift/getSpace.go +++ b/sdk/go/spacelift/getSpace.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Space` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// space, err := spacelift.LookupSpace(ctx, &GetSpaceArgs{ +// space, err := spacelift.LookupSpace(ctx, &spacelift.LookupSpaceArgs{ // SpaceId: spacelift_space.Space.Id, // }, nil) // if err != nil { @@ -39,7 +41,7 @@ import ( // // ``` func LookupSpace(ctx *pulumi.Context, args *LookupSpaceArgs, opts ...pulumi.InvokeOption) (*LookupSpaceResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupSpaceResult err := ctx.Invoke("spacelift:index/getSpace:getSpace", args, &rv, opts...) if err != nil { @@ -62,6 +64,8 @@ type LookupSpaceResult struct { Id string `pulumi:"id"` // indication whether access to this space inherits read access to entities from the parent space InheritEntities bool `pulumi:"inheritEntities"` + // list of labels describing a space + Labels []string `pulumi:"labels"` // name of the space Name string `pulumi:"name"` // immutable ID (slug) of parent space @@ -108,6 +112,12 @@ func (o LookupSpaceResultOutput) ToLookupSpaceResultOutputWithContext(ctx contex return o } +func (o LookupSpaceResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupSpaceResult] { + return pulumix.Output[LookupSpaceResult]{ + OutputState: o.OutputState, + } +} + // free-form space description for users func (o LookupSpaceResultOutput) Description() pulumi.StringOutput { return o.ApplyT(func(v LookupSpaceResult) string { return v.Description }).(pulumi.StringOutput) @@ -123,6 +133,11 @@ func (o LookupSpaceResultOutput) InheritEntities() pulumi.BoolOutput { return o.ApplyT(func(v LookupSpaceResult) bool { return v.InheritEntities }).(pulumi.BoolOutput) } +// list of labels describing a space +func (o LookupSpaceResultOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupSpaceResult) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + // name of the space func (o LookupSpaceResultOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v LookupSpaceResult) string { return v.Name }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getSpaceByPath.go b/sdk/go/spacelift/getSpaceByPath.go new file mode 100644 index 0000000..4497350 --- /dev/null +++ b/sdk/go/spacelift/getSpaceByPath.go @@ -0,0 +1,160 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `getSpaceByPath` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. In contrary to `Space`, this resource is identified by a path, not by an ID. For this data source to work, path must be unique. If there are multiple spaces with the same path, this datasource will fail. +// **Disclaimer:** +// This datasource can only be used in a stack that resides in a space with inheritance enabled. In addition, the parent spaces (excluding root) must also have inheritance enabled. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// space, err := spacelift.GetSpaceByPath(ctx, &spacelift.GetSpaceByPathArgs{ +// SpacePath: "root/second space/my space", +// }, nil) +// if err != nil { +// return err +// } +// ctx.Export("spaceDescription", space.Description) +// return nil +// }) +// } +// +// ``` +func GetSpaceByPath(ctx *pulumi.Context, args *GetSpaceByPathArgs, opts ...pulumi.InvokeOption) (*GetSpaceByPathResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetSpaceByPathResult + err := ctx.Invoke("spacelift:index/getSpaceByPath:getSpaceByPath", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getSpaceByPath. +type GetSpaceByPathArgs struct { + // path to the space - a series of space names separated by `/` + SpacePath string `pulumi:"spacePath"` +} + +// A collection of values returned by getSpaceByPath. +type GetSpaceByPathResult struct { + // free-form space description for users + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // indication whether access to this space inherits read access to entities from the parent space + InheritEntities bool `pulumi:"inheritEntities"` + // list of labels describing a space + Labels []string `pulumi:"labels"` + // name of the space + Name string `pulumi:"name"` + // immutable ID (slug) of parent space + ParentSpaceId string `pulumi:"parentSpaceId"` + // path to the space - a series of space names separated by `/` + SpacePath string `pulumi:"spacePath"` +} + +func GetSpaceByPathOutput(ctx *pulumi.Context, args GetSpaceByPathOutputArgs, opts ...pulumi.InvokeOption) GetSpaceByPathResultOutput { + return pulumi.ToOutputWithContext(context.Background(), args). + ApplyT(func(v interface{}) (GetSpaceByPathResult, error) { + args := v.(GetSpaceByPathArgs) + r, err := GetSpaceByPath(ctx, &args, opts...) + var s GetSpaceByPathResult + if r != nil { + s = *r + } + return s, err + }).(GetSpaceByPathResultOutput) +} + +// A collection of arguments for invoking getSpaceByPath. +type GetSpaceByPathOutputArgs struct { + // path to the space - a series of space names separated by `/` + SpacePath pulumi.StringInput `pulumi:"spacePath"` +} + +func (GetSpaceByPathOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSpaceByPathArgs)(nil)).Elem() +} + +// A collection of values returned by getSpaceByPath. +type GetSpaceByPathResultOutput struct{ *pulumi.OutputState } + +func (GetSpaceByPathResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSpaceByPathResult)(nil)).Elem() +} + +func (o GetSpaceByPathResultOutput) ToGetSpaceByPathResultOutput() GetSpaceByPathResultOutput { + return o +} + +func (o GetSpaceByPathResultOutput) ToGetSpaceByPathResultOutputWithContext(ctx context.Context) GetSpaceByPathResultOutput { + return o +} + +func (o GetSpaceByPathResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetSpaceByPathResult] { + return pulumix.Output[GetSpaceByPathResult]{ + OutputState: o.OutputState, + } +} + +// free-form space description for users +func (o GetSpaceByPathResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetSpaceByPathResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetSpaceByPathResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetSpaceByPathResult) string { return v.Id }).(pulumi.StringOutput) +} + +// indication whether access to this space inherits read access to entities from the parent space +func (o GetSpaceByPathResultOutput) InheritEntities() pulumi.BoolOutput { + return o.ApplyT(func(v GetSpaceByPathResult) bool { return v.InheritEntities }).(pulumi.BoolOutput) +} + +// list of labels describing a space +func (o GetSpaceByPathResultOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetSpaceByPathResult) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +// name of the space +func (o GetSpaceByPathResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetSpaceByPathResult) string { return v.Name }).(pulumi.StringOutput) +} + +// immutable ID (slug) of parent space +func (o GetSpaceByPathResultOutput) ParentSpaceId() pulumi.StringOutput { + return o.ApplyT(func(v GetSpaceByPathResult) string { return v.ParentSpaceId }).(pulumi.StringOutput) +} + +// path to the space - a series of space names separated by `/` +func (o GetSpaceByPathResultOutput) SpacePath() pulumi.StringOutput { + return o.ApplyT(func(v GetSpaceByPathResult) string { return v.SpacePath }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetSpaceByPathResultOutput{}) +} diff --git a/sdk/go/spacelift/getSpaces.go b/sdk/go/spacelift/getSpaces.go new file mode 100644 index 0000000..1bb1c1a --- /dev/null +++ b/sdk/go/spacelift/getSpaces.go @@ -0,0 +1,101 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `getSpaces` can find all spaces in the spacelift organization. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// this, err := spacelift.GetSpaces(ctx, nil, nil) +// if err != nil { +// return err +// } +// ctx.Export("spaces", this.Spaces) +// return nil +// }) +// } +// +// ``` +func GetSpaces(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetSpacesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetSpacesResult + err := ctx.Invoke("spacelift:index/getSpaces:getSpaces", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getSpaces. +type GetSpacesResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Spaces []GetSpacesSpace `pulumi:"spaces"` +} + +func GetSpacesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetSpacesResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetSpacesResult, error) { + r, err := GetSpaces(ctx, opts...) + var s GetSpacesResult + if r != nil { + s = *r + } + return s, err + }).(GetSpacesResultOutput) +} + +// A collection of values returned by getSpaces. +type GetSpacesResultOutput struct{ *pulumi.OutputState } + +func (GetSpacesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSpacesResult)(nil)).Elem() +} + +func (o GetSpacesResultOutput) ToGetSpacesResultOutput() GetSpacesResultOutput { + return o +} + +func (o GetSpacesResultOutput) ToGetSpacesResultOutputWithContext(ctx context.Context) GetSpacesResultOutput { + return o +} + +func (o GetSpacesResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetSpacesResult] { + return pulumix.Output[GetSpacesResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetSpacesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetSpacesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetSpacesResultOutput) Spaces() GetSpacesSpaceArrayOutput { + return o.ApplyT(func(v GetSpacesResult) []GetSpacesSpace { return v.Spaces }).(GetSpacesSpaceArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetSpacesResultOutput{}) +} diff --git a/sdk/go/spacelift/getStack.go b/sdk/go/spacelift/getStack.go index ee2ee67..b653eed 100644 --- a/sdk/go/spacelift/getStack.go +++ b/sdk/go/spacelift/getStack.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Stack` combines source code and configuration to create a runtime environment where resources are managed. In this way it's similar to a stack in AWS CloudFormation, or a project on generic CI/CD platforms. @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupStack(ctx, &GetStackArgs{ +// _, err := spacelift.LookupStack(ctx, &spacelift.LookupStackArgs{ // StackId: "k8s-core", // }, nil) // if err != nil { @@ -38,7 +40,7 @@ import ( // // ``` func LookupStack(ctx *pulumi.Context, args *LookupStackArgs, opts ...pulumi.InvokeOption) (*LookupStackResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupStackResult err := ctx.Invoke("spacelift:index/getStack:getStack", args, &rv, opts...) if err != nil { @@ -59,6 +61,8 @@ type LookupStackArgs struct { AfterPerforms []string `pulumi:"afterPerforms"` // List of after-plan scripts AfterPlans []string `pulumi:"afterPlans"` + // List of after-run scripts + AfterRuns []string `pulumi:"afterRuns"` // List of before-apply scripts BeforeApplies []string `pulumi:"beforeApplies"` // List of before-destroy scripts @@ -87,6 +91,8 @@ type LookupStackResult struct { AfterPerforms []string `pulumi:"afterPerforms"` // List of after-plan scripts AfterPlans []string `pulumi:"afterPlans"` + // List of after-run scripts + AfterRuns []string `pulumi:"afterRuns"` // Ansible-specific configuration. Presence means this Stack is an Ansible Stack. Ansibles []GetStackAnsible `pulumi:"ansibles"` // indicates whether changes to this stack can be automatically deployed @@ -138,6 +144,8 @@ type LookupStackResult struct { ProtectFromDeletion bool `pulumi:"protectFromDeletion"` // Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. Pulumis []GetStackPulumi `pulumi:"pulumis"` + // One-way VCS integration using a raw Git repository link + RawGits []GetStackRawGit `pulumi:"rawGits"` // Name of the repository, without the owner part Repository string `pulumi:"repository"` // Name of the Docker image used to process Runs @@ -147,10 +155,14 @@ type LookupStackResult struct { // ID (slug) of the space the stack is in SpaceId string `pulumi:"spaceId"` // ID (slug) of the stack - StackId string `pulumi:"stackId"` - TerraformSmartSanitization bool `pulumi:"terraformSmartSanitization"` - TerraformVersion string `pulumi:"terraformVersion"` - TerraformWorkspace string `pulumi:"terraformWorkspace"` + StackId string `pulumi:"stackId"` + // Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. + TerraformExternalStateAccess bool `pulumi:"terraformExternalStateAccess"` + TerraformSmartSanitization bool `pulumi:"terraformSmartSanitization"` + TerraformVersion string `pulumi:"terraformVersion"` + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. + TerraformWorkflowTool string `pulumi:"terraformWorkflowTool"` + TerraformWorkspace string `pulumi:"terraformWorkspace"` // ID of the worker pool to use WorkerPoolId string `pulumi:"workerPoolId"` } @@ -180,6 +192,8 @@ type LookupStackOutputArgs struct { AfterPerforms pulumi.StringArrayInput `pulumi:"afterPerforms"` // List of after-plan scripts AfterPlans pulumi.StringArrayInput `pulumi:"afterPlans"` + // List of after-run scripts + AfterRuns pulumi.StringArrayInput `pulumi:"afterRuns"` // List of before-apply scripts BeforeApplies pulumi.StringArrayInput `pulumi:"beforeApplies"` // List of before-destroy scripts @@ -213,6 +227,12 @@ func (o LookupStackResultOutput) ToLookupStackResultOutputWithContext(ctx contex return o } +func (o LookupStackResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupStackResult] { + return pulumix.Output[LookupStackResult]{ + OutputState: o.OutputState, + } +} + // indicates whether this stack can administer others func (o LookupStackResultOutput) Administrative() pulumi.BoolOutput { return o.ApplyT(func(v LookupStackResult) bool { return v.Administrative }).(pulumi.BoolOutput) @@ -243,6 +263,11 @@ func (o LookupStackResultOutput) AfterPlans() pulumi.StringArrayOutput { return o.ApplyT(func(v LookupStackResult) []string { return v.AfterPlans }).(pulumi.StringArrayOutput) } +// List of after-run scripts +func (o LookupStackResultOutput) AfterRuns() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupStackResult) []string { return v.AfterRuns }).(pulumi.StringArrayOutput) +} + // Ansible-specific configuration. Presence means this Stack is an Ansible Stack. func (o LookupStackResultOutput) Ansibles() GetStackAnsibleArrayOutput { return o.ApplyT(func(v LookupStackResult) []GetStackAnsible { return v.Ansibles }).(GetStackAnsibleArrayOutput) @@ -372,6 +397,11 @@ func (o LookupStackResultOutput) Pulumis() GetStackPulumiArrayOutput { return o.ApplyT(func(v LookupStackResult) []GetStackPulumi { return v.Pulumis }).(GetStackPulumiArrayOutput) } +// One-way VCS integration using a raw Git repository link +func (o LookupStackResultOutput) RawGits() GetStackRawGitArrayOutput { + return o.ApplyT(func(v LookupStackResult) []GetStackRawGit { return v.RawGits }).(GetStackRawGitArrayOutput) +} + // Name of the repository, without the owner part func (o LookupStackResultOutput) Repository() pulumi.StringOutput { return o.ApplyT(func(v LookupStackResult) string { return v.Repository }).(pulumi.StringOutput) @@ -397,6 +427,11 @@ func (o LookupStackResultOutput) StackId() pulumi.StringOutput { return o.ApplyT(func(v LookupStackResult) string { return v.StackId }).(pulumi.StringOutput) } +// Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. +func (o LookupStackResultOutput) TerraformExternalStateAccess() pulumi.BoolOutput { + return o.ApplyT(func(v LookupStackResult) bool { return v.TerraformExternalStateAccess }).(pulumi.BoolOutput) +} + func (o LookupStackResultOutput) TerraformSmartSanitization() pulumi.BoolOutput { return o.ApplyT(func(v LookupStackResult) bool { return v.TerraformSmartSanitization }).(pulumi.BoolOutput) } @@ -405,6 +440,11 @@ func (o LookupStackResultOutput) TerraformVersion() pulumi.StringOutput { return o.ApplyT(func(v LookupStackResult) string { return v.TerraformVersion }).(pulumi.StringOutput) } +// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. +func (o LookupStackResultOutput) TerraformWorkflowTool() pulumi.StringOutput { + return o.ApplyT(func(v LookupStackResult) string { return v.TerraformWorkflowTool }).(pulumi.StringOutput) +} + func (o LookupStackResultOutput) TerraformWorkspace() pulumi.StringOutput { return o.ApplyT(func(v LookupStackResult) string { return v.TerraformWorkspace }).(pulumi.StringOutput) } diff --git a/sdk/go/spacelift/getStackAwsRole.go b/sdk/go/spacelift/getStackAwsRole.go index 3fdbd60..824520f 100644 --- a/sdk/go/spacelift/getStackAwsRole.go +++ b/sdk/go/spacelift/getStackAwsRole.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // > **Note:** `StackAwsRole` is deprecated. Please use `AwsRole` instead. The functionality is identical. @@ -26,19 +28,19 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupStackAwsRole(ctx, &GetStackAwsRoleArgs{ +// _, err := spacelift.LookupStackAwsRole(ctx, &spacelift.LookupStackAwsRoleArgs{ // ModuleId: pulumi.StringRef("k8s-module"), // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupStackAwsRole(ctx, &GetStackAwsRoleArgs{ +// _, err = spacelift.LookupStackAwsRole(ctx, &spacelift.LookupStackAwsRoleArgs{ // StackId: pulumi.StringRef("k8s-core"), // }, nil) // if err != nil { @@ -50,7 +52,7 @@ import ( // // ``` func LookupStackAwsRole(ctx *pulumi.Context, args *LookupStackAwsRoleArgs, opts ...pulumi.InvokeOption) (*LookupStackAwsRoleResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupStackAwsRoleResult err := ctx.Invoke("spacelift:index/getStackAwsRole:getStackAwsRole", args, &rv, opts...) if err != nil { @@ -125,6 +127,12 @@ func (o LookupStackAwsRoleResultOutput) ToLookupStackAwsRoleResultOutputWithCont return o } +func (o LookupStackAwsRoleResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupStackAwsRoleResult] { + return pulumix.Output[LookupStackAwsRoleResult]{ + OutputState: o.OutputState, + } +} + // AWS IAM role session duration in seconds func (o LookupStackAwsRoleResultOutput) DurationSeconds() pulumi.IntOutput { return o.ApplyT(func(v LookupStackAwsRoleResult) int { return v.DurationSeconds }).(pulumi.IntOutput) diff --git a/sdk/go/spacelift/getStackGcpServiceAccount.go b/sdk/go/spacelift/getStackGcpServiceAccount.go index a2aff86..2124419 100644 --- a/sdk/go/spacelift/getStackGcpServiceAccount.go +++ b/sdk/go/spacelift/getStackGcpServiceAccount.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // ## Example Usage @@ -18,19 +20,19 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupStackGcpServiceAccount(ctx, &GetStackGcpServiceAccountArgs{ +// _, err := spacelift.LookupStackGcpServiceAccount(ctx, &spacelift.LookupStackGcpServiceAccountArgs{ // ModuleId: pulumi.StringRef("k8s-module"), // }, nil) // if err != nil { // return err // } -// _, err = spacelift.LookupStackGcpServiceAccount(ctx, &GetStackGcpServiceAccountArgs{ +// _, err = spacelift.LookupStackGcpServiceAccount(ctx, &spacelift.LookupStackGcpServiceAccountArgs{ // StackId: pulumi.StringRef("k8s-core"), // }, nil) // if err != nil { @@ -42,7 +44,7 @@ import ( // // ``` func LookupStackGcpServiceAccount(ctx *pulumi.Context, args *LookupStackGcpServiceAccountArgs, opts ...pulumi.InvokeOption) (*LookupStackGcpServiceAccountResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupStackGcpServiceAccountResult err := ctx.Invoke("spacelift:index/getStackGcpServiceAccount:getStackGcpServiceAccount", args, &rv, opts...) if err != nil { @@ -113,6 +115,12 @@ func (o LookupStackGcpServiceAccountResultOutput) ToLookupStackGcpServiceAccount return o } +func (o LookupStackGcpServiceAccountResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupStackGcpServiceAccountResult] { + return pulumix.Output[LookupStackGcpServiceAccountResult]{ + OutputState: o.OutputState, + } +} + // The provider-assigned unique ID for this managed resource. func (o LookupStackGcpServiceAccountResultOutput) Id() pulumi.StringOutput { return o.ApplyT(func(v LookupStackGcpServiceAccountResult) string { return v.Id }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getStacks.go b/sdk/go/spacelift/getStacks.go new file mode 100644 index 0000000..0f395fe --- /dev/null +++ b/sdk/go/spacelift/getStacks.go @@ -0,0 +1,201 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `getStacks` represents all the stacks in the Spacelift account visible to the API user, matching predicates. +func GetStacks(ctx *pulumi.Context, args *GetStacksArgs, opts ...pulumi.InvokeOption) (*GetStacksResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetStacksResult + err := ctx.Invoke("spacelift:index/getStacks:getStacks", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getStacks. +type GetStacksArgs struct { + Administrative *GetStacksAdministrative `pulumi:"administrative"` + Branch *GetStacksBranch `pulumi:"branch"` + // Require stacks to be on one of the commits + Commit *GetStacksCommit `pulumi:"commit"` + Labels []GetStacksLabel `pulumi:"labels"` + // Require stacks to be locked + Locked *GetStacksLocked `pulumi:"locked"` + Name *GetStacksName `pulumi:"name"` + ProjectRoot *GetStacksProjectRoot `pulumi:"projectRoot"` + Repository *GetStacksRepository `pulumi:"repository"` + // Require stacks to have one of the states + State *GetStacksState `pulumi:"state"` + // Require stacks to use one of the IaC vendors + Vendor *GetStacksVendor `pulumi:"vendor"` + // Require stacks to use one of the worker pools + WorkerPool *GetStacksWorkerPool `pulumi:"workerPool"` +} + +// A collection of values returned by getStacks. +type GetStacksResult struct { + // Require stacks to be administrative or not + Administrative *GetStacksAdministrative `pulumi:"administrative"` + // Require stacks to be on one of the branches + Branch *GetStacksBranch `pulumi:"branch"` + // Require stacks to be on one of the commits + Commit *GetStacksCommit `pulumi:"commit"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Require stacks to have one of the labels + Labels []GetStacksLabel `pulumi:"labels"` + // Require stacks to be locked + Locked *GetStacksLocked `pulumi:"locked"` + // Require stacks to have one of the names + Name *GetStacksName `pulumi:"name"` + // Require stacks to be in one of the project roots + ProjectRoot *GetStacksProjectRoot `pulumi:"projectRoot"` + // Require stacks to be in one of the repositories + Repository *GetStacksRepository `pulumi:"repository"` + // List of stacks matching the predicates + Stacks []GetStacksStack `pulumi:"stacks"` + // Require stacks to have one of the states + State *GetStacksState `pulumi:"state"` + // Require stacks to use one of the IaC vendors + Vendor *GetStacksVendor `pulumi:"vendor"` + // Require stacks to use one of the worker pools + WorkerPool *GetStacksWorkerPool `pulumi:"workerPool"` +} + +func GetStacksOutput(ctx *pulumi.Context, args GetStacksOutputArgs, opts ...pulumi.InvokeOption) GetStacksResultOutput { + return pulumi.ToOutputWithContext(context.Background(), args). + ApplyT(func(v interface{}) (GetStacksResult, error) { + args := v.(GetStacksArgs) + r, err := GetStacks(ctx, &args, opts...) + var s GetStacksResult + if r != nil { + s = *r + } + return s, err + }).(GetStacksResultOutput) +} + +// A collection of arguments for invoking getStacks. +type GetStacksOutputArgs struct { + Administrative GetStacksAdministrativePtrInput `pulumi:"administrative"` + Branch GetStacksBranchPtrInput `pulumi:"branch"` + // Require stacks to be on one of the commits + Commit GetStacksCommitPtrInput `pulumi:"commit"` + Labels GetStacksLabelArrayInput `pulumi:"labels"` + // Require stacks to be locked + Locked GetStacksLockedPtrInput `pulumi:"locked"` + Name GetStacksNamePtrInput `pulumi:"name"` + ProjectRoot GetStacksProjectRootPtrInput `pulumi:"projectRoot"` + Repository GetStacksRepositoryPtrInput `pulumi:"repository"` + // Require stacks to have one of the states + State GetStacksStatePtrInput `pulumi:"state"` + // Require stacks to use one of the IaC vendors + Vendor GetStacksVendorPtrInput `pulumi:"vendor"` + // Require stacks to use one of the worker pools + WorkerPool GetStacksWorkerPoolPtrInput `pulumi:"workerPool"` +} + +func (GetStacksOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksArgs)(nil)).Elem() +} + +// A collection of values returned by getStacks. +type GetStacksResultOutput struct{ *pulumi.OutputState } + +func (GetStacksResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksResult)(nil)).Elem() +} + +func (o GetStacksResultOutput) ToGetStacksResultOutput() GetStacksResultOutput { + return o +} + +func (o GetStacksResultOutput) ToGetStacksResultOutputWithContext(ctx context.Context) GetStacksResultOutput { + return o +} + +func (o GetStacksResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksResult] { + return pulumix.Output[GetStacksResult]{ + OutputState: o.OutputState, + } +} + +// Require stacks to be administrative or not +func (o GetStacksResultOutput) Administrative() GetStacksAdministrativePtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksAdministrative { return v.Administrative }).(GetStacksAdministrativePtrOutput) +} + +// Require stacks to be on one of the branches +func (o GetStacksResultOutput) Branch() GetStacksBranchPtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksBranch { return v.Branch }).(GetStacksBranchPtrOutput) +} + +// Require stacks to be on one of the commits +func (o GetStacksResultOutput) Commit() GetStacksCommitPtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksCommit { return v.Commit }).(GetStacksCommitPtrOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetStacksResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Require stacks to have one of the labels +func (o GetStacksResultOutput) Labels() GetStacksLabelArrayOutput { + return o.ApplyT(func(v GetStacksResult) []GetStacksLabel { return v.Labels }).(GetStacksLabelArrayOutput) +} + +// Require stacks to be locked +func (o GetStacksResultOutput) Locked() GetStacksLockedPtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksLocked { return v.Locked }).(GetStacksLockedPtrOutput) +} + +// Require stacks to have one of the names +func (o GetStacksResultOutput) Name() GetStacksNamePtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksName { return v.Name }).(GetStacksNamePtrOutput) +} + +// Require stacks to be in one of the project roots +func (o GetStacksResultOutput) ProjectRoot() GetStacksProjectRootPtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksProjectRoot { return v.ProjectRoot }).(GetStacksProjectRootPtrOutput) +} + +// Require stacks to be in one of the repositories +func (o GetStacksResultOutput) Repository() GetStacksRepositoryPtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksRepository { return v.Repository }).(GetStacksRepositoryPtrOutput) +} + +// List of stacks matching the predicates +func (o GetStacksResultOutput) Stacks() GetStacksStackArrayOutput { + return o.ApplyT(func(v GetStacksResult) []GetStacksStack { return v.Stacks }).(GetStacksStackArrayOutput) +} + +// Require stacks to have one of the states +func (o GetStacksResultOutput) State() GetStacksStatePtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksState { return v.State }).(GetStacksStatePtrOutput) +} + +// Require stacks to use one of the IaC vendors +func (o GetStacksResultOutput) Vendor() GetStacksVendorPtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksVendor { return v.Vendor }).(GetStacksVendorPtrOutput) +} + +// Require stacks to use one of the worker pools +func (o GetStacksResultOutput) WorkerPool() GetStacksWorkerPoolPtrOutput { + return o.ApplyT(func(v GetStacksResult) *GetStacksWorkerPool { return v.WorkerPool }).(GetStacksWorkerPoolPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(GetStacksResultOutput{}) +} diff --git a/sdk/go/spacelift/getVcsAgentPool.go b/sdk/go/spacelift/getVcsAgentPool.go index 4db9ffa..6e5c5d7 100644 --- a/sdk/go/spacelift/getVcsAgentPool.go +++ b/sdk/go/spacelift/getVcsAgentPool.go @@ -8,11 +8,13 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `VcsAgentPool` represents a Spacelift **VCS agent pool** - a logical group of proxies allowing Spacelift to access private VCS installations func LookupVcsAgentPool(ctx *pulumi.Context, args *LookupVcsAgentPoolArgs, opts ...pulumi.InvokeOption) (*LookupVcsAgentPoolResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupVcsAgentPoolResult err := ctx.Invoke("spacelift:index/getVcsAgentPool:getVcsAgentPool", args, &rv, opts...) if err != nil { @@ -77,6 +79,12 @@ func (o LookupVcsAgentPoolResultOutput) ToLookupVcsAgentPoolResultOutputWithCont return o } +func (o LookupVcsAgentPoolResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupVcsAgentPoolResult] { + return pulumix.Output[LookupVcsAgentPoolResult]{ + OutputState: o.OutputState, + } +} + // Free-form VCS agent pool description for users func (o LookupVcsAgentPoolResultOutput) Description() pulumi.StringOutput { return o.ApplyT(func(v LookupVcsAgentPoolResult) string { return v.Description }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getVcsAgentPools.go b/sdk/go/spacelift/getVcsAgentPools.go index d1f4221..9d66b62 100644 --- a/sdk/go/spacelift/getVcsAgentPools.go +++ b/sdk/go/spacelift/getVcsAgentPools.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getVcsAgentPools` represents the VCS agent pools assigned to the Spacelift account. @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetVcsAgentPools(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetVcsAgentPoolsResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetVcsAgentPoolsResult err := ctx.Invoke("spacelift:index/getVcsAgentPools:getVcsAgentPools", nil, &rv, opts...) if err != nil { @@ -48,3 +53,48 @@ type GetVcsAgentPoolsResult struct { Id string `pulumi:"id"` VcsAgentPools []GetVcsAgentPoolsVcsAgentPool `pulumi:"vcsAgentPools"` } + +func GetVcsAgentPoolsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetVcsAgentPoolsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetVcsAgentPoolsResult, error) { + r, err := GetVcsAgentPools(ctx, opts...) + var s GetVcsAgentPoolsResult + if r != nil { + s = *r + } + return s, err + }).(GetVcsAgentPoolsResultOutput) +} + +// A collection of values returned by getVcsAgentPools. +type GetVcsAgentPoolsResultOutput struct{ *pulumi.OutputState } + +func (GetVcsAgentPoolsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetVcsAgentPoolsResult)(nil)).Elem() +} + +func (o GetVcsAgentPoolsResultOutput) ToGetVcsAgentPoolsResultOutput() GetVcsAgentPoolsResultOutput { + return o +} + +func (o GetVcsAgentPoolsResultOutput) ToGetVcsAgentPoolsResultOutputWithContext(ctx context.Context) GetVcsAgentPoolsResultOutput { + return o +} + +func (o GetVcsAgentPoolsResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetVcsAgentPoolsResult] { + return pulumix.Output[GetVcsAgentPoolsResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetVcsAgentPoolsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetVcsAgentPoolsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetVcsAgentPoolsResultOutput) VcsAgentPools() GetVcsAgentPoolsVcsAgentPoolArrayOutput { + return o.ApplyT(func(v GetVcsAgentPoolsResult) []GetVcsAgentPoolsVcsAgentPool { return v.VcsAgentPools }).(GetVcsAgentPoolsVcsAgentPoolArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetVcsAgentPoolsResultOutput{}) +} diff --git a/sdk/go/spacelift/getWebhook.go b/sdk/go/spacelift/getWebhook.go index 3ef4b76..2345311 100644 --- a/sdk/go/spacelift/getWebhook.go +++ b/sdk/go/spacelift/getWebhook.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Webhook` represents a webhook endpoint to which Spacelift sends the POST request about run state changes. @@ -20,13 +22,13 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupWebhook(ctx, &GetWebhookArgs{ +// _, err := spacelift.LookupWebhook(ctx, &spacelift.LookupWebhookArgs{ // WebhookId: spacelift_webhook.Webhook.Id, // }, nil) // if err != nil { @@ -38,7 +40,7 @@ import ( // // ``` func LookupWebhook(ctx *pulumi.Context, args *LookupWebhookArgs, opts ...pulumi.InvokeOption) (*LookupWebhookResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupWebhookResult err := ctx.Invoke("spacelift:index/getWebhook:getWebhook", args, &rv, opts...) if err != nil { @@ -117,6 +119,12 @@ func (o LookupWebhookResultOutput) ToLookupWebhookResultOutputWithContext(ctx co return o } +func (o LookupWebhookResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupWebhookResult] { + return pulumix.Output[LookupWebhookResult]{ + OutputState: o.OutputState, + } +} + // enables or disables sending webhooks func (o LookupWebhookResultOutput) Enabled() pulumi.BoolOutput { return o.ApplyT(func(v LookupWebhookResult) bool { return v.Enabled }).(pulumi.BoolOutput) diff --git a/sdk/go/spacelift/getWorkerPool.go b/sdk/go/spacelift/getWorkerPool.go index e183155..8c77249 100644 --- a/sdk/go/spacelift/getWorkerPool.go +++ b/sdk/go/spacelift/getWorkerPool.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `WorkerPool` represents a worker pool assigned to the Spacelift account. @@ -20,14 +22,14 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func main() { // pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.LookupWorkerPool(ctx, &GetWorkerPoolArgs{ -// WorkerPoolId: "k8s-core", +// _, err := spacelift.LookupWorkerPool(ctx, &spacelift.LookupWorkerPoolArgs{ +// WorkerPoolId: "01G1KTZ4BA86RBN3XNN3YK9EWT", // }, nil) // if err != nil { // return err @@ -38,7 +40,7 @@ import ( // // ``` func LookupWorkerPool(ctx *pulumi.Context, args *LookupWorkerPoolArgs, opts ...pulumi.InvokeOption) (*LookupWorkerPoolResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv LookupWorkerPoolResult err := ctx.Invoke("spacelift:index/getWorkerPool:getWorkerPool", args, &rv, opts...) if err != nil { @@ -108,6 +110,12 @@ func (o LookupWorkerPoolResultOutput) ToLookupWorkerPoolResultOutputWithContext( return o } +func (o LookupWorkerPoolResultOutput) ToOutput(ctx context.Context) pulumix.Output[LookupWorkerPoolResult] { + return pulumix.Output[LookupWorkerPoolResult]{ + OutputState: o.OutputState, + } +} + // credentials necessary to connect WorkerPool's workers to the control plane func (o LookupWorkerPoolResultOutput) Config() pulumi.StringOutput { return o.ApplyT(func(v LookupWorkerPoolResult) string { return v.Config }).(pulumi.StringOutput) diff --git a/sdk/go/spacelift/getWorkerPools.go b/sdk/go/spacelift/getWorkerPools.go index c3d677e..7ad648e 100644 --- a/sdk/go/spacelift/getWorkerPools.go +++ b/sdk/go/spacelift/getWorkerPools.go @@ -4,7 +4,12 @@ package spacelift import ( + "context" + "reflect" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `getWorkerPools` represents the worker pools assigned to the Spacelift account. @@ -17,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -33,7 +38,7 @@ import ( // // ``` func GetWorkerPools(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetWorkerPoolsResult, error) { - opts = pkgInvokeDefaultOpts(opts) + opts = internal.PkgInvokeDefaultOpts(opts) var rv GetWorkerPoolsResult err := ctx.Invoke("spacelift:index/getWorkerPools:getWorkerPools", nil, &rv, opts...) if err != nil { @@ -48,3 +53,48 @@ type GetWorkerPoolsResult struct { Id string `pulumi:"id"` WorkerPools []GetWorkerPoolsWorkerPool `pulumi:"workerPools"` } + +func GetWorkerPoolsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetWorkerPoolsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetWorkerPoolsResult, error) { + r, err := GetWorkerPools(ctx, opts...) + var s GetWorkerPoolsResult + if r != nil { + s = *r + } + return s, err + }).(GetWorkerPoolsResultOutput) +} + +// A collection of values returned by getWorkerPools. +type GetWorkerPoolsResultOutput struct{ *pulumi.OutputState } + +func (GetWorkerPoolsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetWorkerPoolsResult)(nil)).Elem() +} + +func (o GetWorkerPoolsResultOutput) ToGetWorkerPoolsResultOutput() GetWorkerPoolsResultOutput { + return o +} + +func (o GetWorkerPoolsResultOutput) ToGetWorkerPoolsResultOutputWithContext(ctx context.Context) GetWorkerPoolsResultOutput { + return o +} + +func (o GetWorkerPoolsResultOutput) ToOutput(ctx context.Context) pulumix.Output[GetWorkerPoolsResult] { + return pulumix.Output[GetWorkerPoolsResult]{ + OutputState: o.OutputState, + } +} + +// The provider-assigned unique ID for this managed resource. +func (o GetWorkerPoolsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetWorkerPoolsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetWorkerPoolsResultOutput) WorkerPools() GetWorkerPoolsWorkerPoolArrayOutput { + return o.ApplyT(func(v GetWorkerPoolsResult) []GetWorkerPoolsWorkerPool { return v.WorkerPools }).(GetWorkerPoolsWorkerPoolArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetWorkerPoolsResultOutput{}) +} diff --git a/sdk/go/spacelift/idpGroupMapping.go b/sdk/go/spacelift/idpGroupMapping.go new file mode 100644 index 0000000..a62e622 --- /dev/null +++ b/sdk/go/spacelift/idpGroupMapping.go @@ -0,0 +1,300 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `IdpGroupMapping` represents a mapping (binding) between a user group (as provided by IdP) and a Spacelift User Management Policy. If you assign permissions (a Policy) to a user group, all users in the group will have those permissions unless the user's permissions are higher than the group's permissions. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := spacelift.NewIdpGroupMapping(ctx, "test", &spacelift.IdpGroupMappingArgs{ +// Policies: spacelift.IdpGroupMappingPolicyArray{ +// &spacelift.IdpGroupMappingPolicyArgs{ +// Role: pulumi.String("ADMIN"), +// SpaceId: pulumi.String("root"), +// }, +// &spacelift.IdpGroupMappingPolicyArgs{ +// Role: pulumi.String("ADMIN"), +// SpaceId: pulumi.String("legacy"), +// }, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type IdpGroupMapping struct { + pulumi.CustomResourceState + + // Name of the user group - should be unique in one account + Name pulumi.StringOutput `pulumi:"name"` + Policies IdpGroupMappingPolicyArrayOutput `pulumi:"policies"` +} + +// NewIdpGroupMapping registers a new resource with the given unique name, arguments, and options. +func NewIdpGroupMapping(ctx *pulumi.Context, + name string, args *IdpGroupMappingArgs, opts ...pulumi.ResourceOption) (*IdpGroupMapping, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Policies == nil { + return nil, errors.New("invalid value for required argument 'Policies'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource IdpGroupMapping + err := ctx.RegisterResource("spacelift:index/idpGroupMapping:IdpGroupMapping", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetIdpGroupMapping gets an existing IdpGroupMapping resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetIdpGroupMapping(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *IdpGroupMappingState, opts ...pulumi.ResourceOption) (*IdpGroupMapping, error) { + var resource IdpGroupMapping + err := ctx.ReadResource("spacelift:index/idpGroupMapping:IdpGroupMapping", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering IdpGroupMapping resources. +type idpGroupMappingState struct { + // Name of the user group - should be unique in one account + Name *string `pulumi:"name"` + Policies []IdpGroupMappingPolicy `pulumi:"policies"` +} + +type IdpGroupMappingState struct { + // Name of the user group - should be unique in one account + Name pulumi.StringPtrInput + Policies IdpGroupMappingPolicyArrayInput +} + +func (IdpGroupMappingState) ElementType() reflect.Type { + return reflect.TypeOf((*idpGroupMappingState)(nil)).Elem() +} + +type idpGroupMappingArgs struct { + // Name of the user group - should be unique in one account + Name *string `pulumi:"name"` + Policies []IdpGroupMappingPolicy `pulumi:"policies"` +} + +// The set of arguments for constructing a IdpGroupMapping resource. +type IdpGroupMappingArgs struct { + // Name of the user group - should be unique in one account + Name pulumi.StringPtrInput + Policies IdpGroupMappingPolicyArrayInput +} + +func (IdpGroupMappingArgs) ElementType() reflect.Type { + return reflect.TypeOf((*idpGroupMappingArgs)(nil)).Elem() +} + +type IdpGroupMappingInput interface { + pulumi.Input + + ToIdpGroupMappingOutput() IdpGroupMappingOutput + ToIdpGroupMappingOutputWithContext(ctx context.Context) IdpGroupMappingOutput +} + +func (*IdpGroupMapping) ElementType() reflect.Type { + return reflect.TypeOf((**IdpGroupMapping)(nil)).Elem() +} + +func (i *IdpGroupMapping) ToIdpGroupMappingOutput() IdpGroupMappingOutput { + return i.ToIdpGroupMappingOutputWithContext(context.Background()) +} + +func (i *IdpGroupMapping) ToIdpGroupMappingOutputWithContext(ctx context.Context) IdpGroupMappingOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdpGroupMappingOutput) +} + +func (i *IdpGroupMapping) ToOutput(ctx context.Context) pulumix.Output[*IdpGroupMapping] { + return pulumix.Output[*IdpGroupMapping]{ + OutputState: i.ToIdpGroupMappingOutputWithContext(ctx).OutputState, + } +} + +// IdpGroupMappingArrayInput is an input type that accepts IdpGroupMappingArray and IdpGroupMappingArrayOutput values. +// You can construct a concrete instance of `IdpGroupMappingArrayInput` via: +// +// IdpGroupMappingArray{ IdpGroupMappingArgs{...} } +type IdpGroupMappingArrayInput interface { + pulumi.Input + + ToIdpGroupMappingArrayOutput() IdpGroupMappingArrayOutput + ToIdpGroupMappingArrayOutputWithContext(context.Context) IdpGroupMappingArrayOutput +} + +type IdpGroupMappingArray []IdpGroupMappingInput + +func (IdpGroupMappingArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*IdpGroupMapping)(nil)).Elem() +} + +func (i IdpGroupMappingArray) ToIdpGroupMappingArrayOutput() IdpGroupMappingArrayOutput { + return i.ToIdpGroupMappingArrayOutputWithContext(context.Background()) +} + +func (i IdpGroupMappingArray) ToIdpGroupMappingArrayOutputWithContext(ctx context.Context) IdpGroupMappingArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdpGroupMappingArrayOutput) +} + +func (i IdpGroupMappingArray) ToOutput(ctx context.Context) pulumix.Output[[]*IdpGroupMapping] { + return pulumix.Output[[]*IdpGroupMapping]{ + OutputState: i.ToIdpGroupMappingArrayOutputWithContext(ctx).OutputState, + } +} + +// IdpGroupMappingMapInput is an input type that accepts IdpGroupMappingMap and IdpGroupMappingMapOutput values. +// You can construct a concrete instance of `IdpGroupMappingMapInput` via: +// +// IdpGroupMappingMap{ "key": IdpGroupMappingArgs{...} } +type IdpGroupMappingMapInput interface { + pulumi.Input + + ToIdpGroupMappingMapOutput() IdpGroupMappingMapOutput + ToIdpGroupMappingMapOutputWithContext(context.Context) IdpGroupMappingMapOutput +} + +type IdpGroupMappingMap map[string]IdpGroupMappingInput + +func (IdpGroupMappingMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*IdpGroupMapping)(nil)).Elem() +} + +func (i IdpGroupMappingMap) ToIdpGroupMappingMapOutput() IdpGroupMappingMapOutput { + return i.ToIdpGroupMappingMapOutputWithContext(context.Background()) +} + +func (i IdpGroupMappingMap) ToIdpGroupMappingMapOutputWithContext(ctx context.Context) IdpGroupMappingMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdpGroupMappingMapOutput) +} + +func (i IdpGroupMappingMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*IdpGroupMapping] { + return pulumix.Output[map[string]*IdpGroupMapping]{ + OutputState: i.ToIdpGroupMappingMapOutputWithContext(ctx).OutputState, + } +} + +type IdpGroupMappingOutput struct{ *pulumi.OutputState } + +func (IdpGroupMappingOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IdpGroupMapping)(nil)).Elem() +} + +func (o IdpGroupMappingOutput) ToIdpGroupMappingOutput() IdpGroupMappingOutput { + return o +} + +func (o IdpGroupMappingOutput) ToIdpGroupMappingOutputWithContext(ctx context.Context) IdpGroupMappingOutput { + return o +} + +func (o IdpGroupMappingOutput) ToOutput(ctx context.Context) pulumix.Output[*IdpGroupMapping] { + return pulumix.Output[*IdpGroupMapping]{ + OutputState: o.OutputState, + } +} + +// Name of the user group - should be unique in one account +func (o IdpGroupMappingOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *IdpGroupMapping) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o IdpGroupMappingOutput) Policies() IdpGroupMappingPolicyArrayOutput { + return o.ApplyT(func(v *IdpGroupMapping) IdpGroupMappingPolicyArrayOutput { return v.Policies }).(IdpGroupMappingPolicyArrayOutput) +} + +type IdpGroupMappingArrayOutput struct{ *pulumi.OutputState } + +func (IdpGroupMappingArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*IdpGroupMapping)(nil)).Elem() +} + +func (o IdpGroupMappingArrayOutput) ToIdpGroupMappingArrayOutput() IdpGroupMappingArrayOutput { + return o +} + +func (o IdpGroupMappingArrayOutput) ToIdpGroupMappingArrayOutputWithContext(ctx context.Context) IdpGroupMappingArrayOutput { + return o +} + +func (o IdpGroupMappingArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*IdpGroupMapping] { + return pulumix.Output[[]*IdpGroupMapping]{ + OutputState: o.OutputState, + } +} + +func (o IdpGroupMappingArrayOutput) Index(i pulumi.IntInput) IdpGroupMappingOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IdpGroupMapping { + return vs[0].([]*IdpGroupMapping)[vs[1].(int)] + }).(IdpGroupMappingOutput) +} + +type IdpGroupMappingMapOutput struct{ *pulumi.OutputState } + +func (IdpGroupMappingMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*IdpGroupMapping)(nil)).Elem() +} + +func (o IdpGroupMappingMapOutput) ToIdpGroupMappingMapOutput() IdpGroupMappingMapOutput { + return o +} + +func (o IdpGroupMappingMapOutput) ToIdpGroupMappingMapOutputWithContext(ctx context.Context) IdpGroupMappingMapOutput { + return o +} + +func (o IdpGroupMappingMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*IdpGroupMapping] { + return pulumix.Output[map[string]*IdpGroupMapping]{ + OutputState: o.OutputState, + } +} + +func (o IdpGroupMappingMapOutput) MapIndex(k pulumi.StringInput) IdpGroupMappingOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IdpGroupMapping { + return vs[0].(map[string]*IdpGroupMapping)[vs[1].(string)] + }).(IdpGroupMappingOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*IdpGroupMappingInput)(nil)).Elem(), &IdpGroupMapping{}) + pulumi.RegisterInputType(reflect.TypeOf((*IdpGroupMappingArrayInput)(nil)).Elem(), IdpGroupMappingArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*IdpGroupMappingMapInput)(nil)).Elem(), IdpGroupMappingMap{}) + pulumi.RegisterOutputType(IdpGroupMappingOutput{}) + pulumi.RegisterOutputType(IdpGroupMappingArrayOutput{}) + pulumi.RegisterOutputType(IdpGroupMappingMapOutput{}) +} diff --git a/sdk/go/spacelift/init.go b/sdk/go/spacelift/init.go index d1a83ad..665616a 100644 --- a/sdk/go/spacelift/init.go +++ b/sdk/go/spacelift/init.go @@ -8,6 +8,7 @@ import ( "github.com/blang/semver" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) type module struct { @@ -30,6 +31,8 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi r = &AzureIntegration{} case "spacelift:index/azureIntegrationAttachment:AzureIntegrationAttachment": r = &AzureIntegrationAttachment{} + case "spacelift:index/blueprint:Blueprint": + r = &Blueprint{} case "spacelift:index/context:Context": r = &Context{} case "spacelift:index/contextAttachment:ContextAttachment": @@ -40,28 +43,50 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi r = &EnvironmentVariable{} case "spacelift:index/gcpServiceAccount:GcpServiceAccount": r = &GcpServiceAccount{} + case "spacelift:index/idpGroupMapping:IdpGroupMapping": + r = &IdpGroupMapping{} case "spacelift:index/module:Module": r = &Module{} case "spacelift:index/mountedfile:Mountedfile": r = &Mountedfile{} + case "spacelift:index/namedWebhook:NamedWebhook": + r = &NamedWebhook{} + case "spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader": + r = &NamedWebhookSecretHeader{} case "spacelift:index/policy:Policy": r = &Policy{} case "spacelift:index/policyAttachment:PolicyAttachment": r = &PolicyAttachment{} case "spacelift:index/run:Run": r = &Run{} + case "spacelift:index/scheduledDeleteTask:ScheduledDeleteTask": + r = &ScheduledDeleteTask{} + case "spacelift:index/scheduledTask:ScheduledTask": + r = &ScheduledTask{} case "spacelift:index/space:Space": r = &Space{} case "spacelift:index/stack:Stack": r = &Stack{} + case "spacelift:index/stackActivator:StackActivator": + r = &StackActivator{} case "spacelift:index/stackAwsRole:StackAwsRole": r = &StackAwsRole{} + case "spacelift:index/stackDependency:StackDependency": + r = &StackDependency{} + case "spacelift:index/stackDependencyReference:StackDependencyReference": + r = &StackDependencyReference{} case "spacelift:index/stackDestructor:StackDestructor": r = &StackDestructor{} case "spacelift:index/stackGcpServiceAccount:StackGcpServiceAccount": r = &StackGcpServiceAccount{} + case "spacelift:index/terraformProvider:TerraformProvider": + r = &TerraformProvider{} + case "spacelift:index/user:User": + r = &User{} case "spacelift:index/vcsAgentPool:VcsAgentPool": r = &VcsAgentPool{} + case "spacelift:index/version:Version": + r = &Version{} case "spacelift:index/webhook:Webhook": r = &Webhook{} case "spacelift:index/workerPool:WorkerPool": @@ -93,7 +118,10 @@ func (p *pkg) ConstructProvider(ctx *pulumi.Context, name, typ, urn string) (pul } func init() { - version, _ := PkgVersion() + version, err := internal.PkgVersion() + if err != nil { + version = semver.Version{Major: 1} + } pulumi.RegisterResourceModule( "spacelift", "index/awsIntegration", @@ -119,6 +147,11 @@ func init() { "index/azureIntegrationAttachment", &module{version}, ) + pulumi.RegisterResourceModule( + "spacelift", + "index/blueprint", + &module{version}, + ) pulumi.RegisterResourceModule( "spacelift", "index/context", @@ -144,6 +177,11 @@ func init() { "index/gcpServiceAccount", &module{version}, ) + pulumi.RegisterResourceModule( + "spacelift", + "index/idpGroupMapping", + &module{version}, + ) pulumi.RegisterResourceModule( "spacelift", "index/module", @@ -154,6 +192,16 @@ func init() { "index/mountedfile", &module{version}, ) + pulumi.RegisterResourceModule( + "spacelift", + "index/namedWebhook", + &module{version}, + ) + pulumi.RegisterResourceModule( + "spacelift", + "index/namedWebhookSecretHeader", + &module{version}, + ) pulumi.RegisterResourceModule( "spacelift", "index/policy", @@ -169,6 +217,16 @@ func init() { "index/run", &module{version}, ) + pulumi.RegisterResourceModule( + "spacelift", + "index/scheduledDeleteTask", + &module{version}, + ) + pulumi.RegisterResourceModule( + "spacelift", + "index/scheduledTask", + &module{version}, + ) pulumi.RegisterResourceModule( "spacelift", "index/space", @@ -179,11 +237,26 @@ func init() { "index/stack", &module{version}, ) + pulumi.RegisterResourceModule( + "spacelift", + "index/stackActivator", + &module{version}, + ) pulumi.RegisterResourceModule( "spacelift", "index/stackAwsRole", &module{version}, ) + pulumi.RegisterResourceModule( + "spacelift", + "index/stackDependency", + &module{version}, + ) + pulumi.RegisterResourceModule( + "spacelift", + "index/stackDependencyReference", + &module{version}, + ) pulumi.RegisterResourceModule( "spacelift", "index/stackDestructor", @@ -194,11 +267,26 @@ func init() { "index/stackGcpServiceAccount", &module{version}, ) + pulumi.RegisterResourceModule( + "spacelift", + "index/terraformProvider", + &module{version}, + ) + pulumi.RegisterResourceModule( + "spacelift", + "index/user", + &module{version}, + ) pulumi.RegisterResourceModule( "spacelift", "index/vcsAgentPool", &module{version}, ) + pulumi.RegisterResourceModule( + "spacelift", + "index/version", + &module{version}, + ) pulumi.RegisterResourceModule( "spacelift", "index/webhook", diff --git a/sdk/go/spacelift/config/pulumiUtilities.go b/sdk/go/spacelift/internal/pulumiUtilities.go similarity index 59% rename from sdk/go/spacelift/config/pulumiUtilities.go rename to sdk/go/spacelift/internal/pulumiUtilities.go index 93d0d58..1fdcb2d 100644 --- a/sdk/go/spacelift/config/pulumiUtilities.go +++ b/sdk/go/spacelift/internal/pulumiUtilities.go @@ -1,7 +1,7 @@ // Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. // *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** -package config +package internal import ( "fmt" @@ -17,7 +17,7 @@ import ( type envParser func(v string) interface{} -func parseEnvBool(v string) interface{} { +func ParseEnvBool(v string) interface{} { b, err := strconv.ParseBool(v) if err != nil { return nil @@ -25,7 +25,7 @@ func parseEnvBool(v string) interface{} { return b } -func parseEnvInt(v string) interface{} { +func ParseEnvInt(v string) interface{} { i, err := strconv.ParseInt(v, 0, 0) if err != nil { return nil @@ -33,7 +33,7 @@ func parseEnvInt(v string) interface{} { return int(i) } -func parseEnvFloat(v string) interface{} { +func ParseEnvFloat(v string) interface{} { f, err := strconv.ParseFloat(v, 64) if err != nil { return nil @@ -41,7 +41,7 @@ func parseEnvFloat(v string) interface{} { return f } -func parseEnvStringArray(v string) interface{} { +func ParseEnvStringArray(v string) interface{} { var result pulumi.StringArray for _, item := range strings.Split(v, ";") { result = append(result, pulumi.String(item)) @@ -49,9 +49,9 @@ func parseEnvStringArray(v string) interface{} { return result } -func getEnvOrDefault(def interface{}, parser envParser, vars ...string) interface{} { +func GetEnvOrDefault(def interface{}, parser envParser, vars ...string) interface{} { for _, v := range vars { - if value := os.Getenv(v); value != "" { + if value, ok := os.LookupEnv(v); ok { if parser != nil { return parser(value) } @@ -65,6 +65,10 @@ func getEnvOrDefault(def interface{}, parser envParser, vars ...string) interfac // If a version cannot be determined, v1 will be assumed. The second return // value is always nil. func PkgVersion() (semver.Version, error) { + // emptyVersion defaults to v0.0.0 + if !SdkVersion.Equals(semver.Version{}) { + return SdkVersion, nil + } type sentinal struct{} pkgPath := reflect.TypeOf(sentinal{}).PkgPath() re := regexp.MustCompile("^.*/pulumi-spacelift/sdk(/v\\d+)?") @@ -79,23 +83,31 @@ func PkgVersion() (semver.Version, error) { } // isZero is a null safe check for if a value is it's types zero value. -func isZero(v interface{}) bool { +func IsZero(v interface{}) bool { if v == nil { return true } return reflect.ValueOf(v).IsZero() } -// pkgResourceDefaultOpts provides package level defaults to pulumi.OptionResource. -func pkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption { - defaults := []pulumi.ResourceOption{pulumi.PluginDownloadURL("https://downloads.spacelift.io/pulumi-plugins")} - +// PkgResourceDefaultOpts provides package level defaults to pulumi.OptionResource. +func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption { + defaults := []pulumi.ResourceOption{} + defaults = append(defaults, pulumi.PluginDownloadURL("https://downloads.spacelift.io/pulumi-plugins")) + version := SdkVersion + if !version.Equals(semver.Version{}) { + defaults = append(defaults, pulumi.Version(version.String())) + } return append(defaults, opts...) } -// pkgInvokeDefaultOpts provides package level defaults to pulumi.OptionInvoke. -func pkgInvokeDefaultOpts(opts []pulumi.InvokeOption) []pulumi.InvokeOption { - defaults := []pulumi.InvokeOption{pulumi.PluginDownloadURL("https://downloads.spacelift.io/pulumi-plugins")} - +// PkgInvokeDefaultOpts provides package level defaults to pulumi.OptionInvoke. +func PkgInvokeDefaultOpts(opts []pulumi.InvokeOption) []pulumi.InvokeOption { + defaults := []pulumi.InvokeOption{} + defaults = append(defaults, pulumi.PluginDownloadURL("https://downloads.spacelift.io/pulumi-plugins")) + version := SdkVersion + if !version.Equals(semver.Version{}) { + defaults = append(defaults, pulumi.Version(version.String())) + } return append(defaults, opts...) } diff --git a/sdk/go/spacelift/internal/pulumiVersion.go b/sdk/go/spacelift/internal/pulumiVersion.go new file mode 100644 index 0000000..d591687 --- /dev/null +++ b/sdk/go/spacelift/internal/pulumiVersion.go @@ -0,0 +1,11 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package internal + +import ( + "github.com/blang/semver" +) + +var SdkVersion semver.Version = semver.Version{} +var pluginDownloadURL string = "" diff --git a/sdk/go/spacelift/module.go b/sdk/go/spacelift/module.go index 9c2437f..9ce0500 100644 --- a/sdk/go/spacelift/module.go +++ b/sdk/go/spacelift/module.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // ## Example Usage @@ -19,7 +21,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -75,6 +77,8 @@ type Module struct { Branch pulumi.StringOutput `pulumi:"branch"` // Free-form module description for users Description pulumi.StringPtrOutput `pulumi:"description"` + // Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + EnableLocalPreview pulumi.BoolPtrOutput `pulumi:"enableLocalPreview"` // GitHub Enterprise (self-hosted) VCS settings GithubEnterprise ModuleGithubEnterprisePtrOutput `pulumi:"githubEnterprise"` // GitLab VCS settings @@ -98,8 +102,10 @@ type Module struct { // naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you // can provide the provider name here. TerraformProvider pulumi.StringOutput `pulumi:"terraformProvider"` - // ID of the worker pool to use + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId pulumi.StringPtrOutput `pulumi:"workerPoolId"` + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + WorkflowTool pulumi.StringOutput `pulumi:"workflowTool"` } // NewModule registers a new resource with the given unique name, arguments, and options. @@ -115,7 +121,7 @@ func NewModule(ctx *pulumi.Context, if args.Repository == nil { return nil, errors.New("invalid value for required argument 'Repository'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource Module err := ctx.RegisterResource("spacelift:index/module:Module", name, args, &resource, opts...) if err != nil { @@ -152,6 +158,8 @@ type moduleState struct { Branch *string `pulumi:"branch"` // Free-form module description for users Description *string `pulumi:"description"` + // Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + EnableLocalPreview *bool `pulumi:"enableLocalPreview"` // GitHub Enterprise (self-hosted) VCS settings GithubEnterprise *ModuleGithubEnterprise `pulumi:"githubEnterprise"` // GitLab VCS settings @@ -175,8 +183,10 @@ type moduleState struct { // naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you // can provide the provider name here. TerraformProvider *string `pulumi:"terraformProvider"` - // ID of the worker pool to use + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId *string `pulumi:"workerPoolId"` + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + WorkflowTool *string `pulumi:"workflowTool"` } type ModuleState struct { @@ -194,6 +204,8 @@ type ModuleState struct { Branch pulumi.StringPtrInput // Free-form module description for users Description pulumi.StringPtrInput + // Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + EnableLocalPreview pulumi.BoolPtrInput // GitHub Enterprise (self-hosted) VCS settings GithubEnterprise ModuleGithubEnterprisePtrInput // GitLab VCS settings @@ -217,8 +229,10 @@ type ModuleState struct { // naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you // can provide the provider name here. TerraformProvider pulumi.StringPtrInput - // ID of the worker pool to use + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId pulumi.StringPtrInput + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + WorkflowTool pulumi.StringPtrInput } func (ModuleState) ElementType() reflect.Type { @@ -238,6 +252,8 @@ type moduleArgs struct { Branch string `pulumi:"branch"` // Free-form module description for users Description *string `pulumi:"description"` + // Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + EnableLocalPreview *bool `pulumi:"enableLocalPreview"` // GitHub Enterprise (self-hosted) VCS settings GithubEnterprise *ModuleGithubEnterprise `pulumi:"githubEnterprise"` // GitLab VCS settings @@ -261,8 +277,10 @@ type moduleArgs struct { // naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you // can provide the provider name here. TerraformProvider *string `pulumi:"terraformProvider"` - // ID of the worker pool to use + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId *string `pulumi:"workerPoolId"` + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + WorkflowTool *string `pulumi:"workflowTool"` } // The set of arguments for constructing a Module resource. @@ -279,6 +297,8 @@ type ModuleArgs struct { Branch pulumi.StringInput // Free-form module description for users Description pulumi.StringPtrInput + // Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + EnableLocalPreview pulumi.BoolPtrInput // GitHub Enterprise (self-hosted) VCS settings GithubEnterprise ModuleGithubEnterprisePtrInput // GitLab VCS settings @@ -302,8 +322,10 @@ type ModuleArgs struct { // naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you // can provide the provider name here. TerraformProvider pulumi.StringPtrInput - // ID of the worker pool to use + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId pulumi.StringPtrInput + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + WorkflowTool pulumi.StringPtrInput } func (ModuleArgs) ElementType() reflect.Type { @@ -329,6 +351,12 @@ func (i *Module) ToModuleOutputWithContext(ctx context.Context) ModuleOutput { return pulumi.ToOutputWithContext(ctx, i).(ModuleOutput) } +func (i *Module) ToOutput(ctx context.Context) pulumix.Output[*Module] { + return pulumix.Output[*Module]{ + OutputState: i.ToModuleOutputWithContext(ctx).OutputState, + } +} + // ModuleArrayInput is an input type that accepts ModuleArray and ModuleArrayOutput values. // You can construct a concrete instance of `ModuleArrayInput` via: // @@ -354,6 +382,12 @@ func (i ModuleArray) ToModuleArrayOutputWithContext(ctx context.Context) ModuleA return pulumi.ToOutputWithContext(ctx, i).(ModuleArrayOutput) } +func (i ModuleArray) ToOutput(ctx context.Context) pulumix.Output[[]*Module] { + return pulumix.Output[[]*Module]{ + OutputState: i.ToModuleArrayOutputWithContext(ctx).OutputState, + } +} + // ModuleMapInput is an input type that accepts ModuleMap and ModuleMapOutput values. // You can construct a concrete instance of `ModuleMapInput` via: // @@ -379,6 +413,12 @@ func (i ModuleMap) ToModuleMapOutputWithContext(ctx context.Context) ModuleMapOu return pulumi.ToOutputWithContext(ctx, i).(ModuleMapOutput) } +func (i ModuleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Module] { + return pulumix.Output[map[string]*Module]{ + OutputState: i.ToModuleMapOutputWithContext(ctx).OutputState, + } +} + type ModuleOutput struct{ *pulumi.OutputState } func (ModuleOutput) ElementType() reflect.Type { @@ -393,6 +433,12 @@ func (o ModuleOutput) ToModuleOutputWithContext(ctx context.Context) ModuleOutpu return o } +func (o ModuleOutput) ToOutput(ctx context.Context) pulumix.Output[*Module] { + return pulumix.Output[*Module]{ + OutputState: o.OutputState, + } +} + // Indicates whether this module can manage others. Defaults to `false`. func (o ModuleOutput) Administrative() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Module) pulumi.BoolPtrOutput { return v.Administrative }).(pulumi.BoolPtrOutput) @@ -428,6 +474,11 @@ func (o ModuleOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v *Module) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) } +// Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. +func (o ModuleOutput) EnableLocalPreview() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Module) pulumi.BoolPtrOutput { return v.EnableLocalPreview }).(pulumi.BoolPtrOutput) +} + // GitHub Enterprise (self-hosted) VCS settings func (o ModuleOutput) GithubEnterprise() ModuleGithubEnterprisePtrOutput { return o.ApplyT(func(v *Module) ModuleGithubEnterprisePtrOutput { return v.GithubEnterprise }).(ModuleGithubEnterprisePtrOutput) @@ -481,11 +532,16 @@ func (o ModuleOutput) TerraformProvider() pulumi.StringOutput { return o.ApplyT(func(v *Module) pulumi.StringOutput { return v.TerraformProvider }).(pulumi.StringOutput) } -// ID of the worker pool to use +// ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. func (o ModuleOutput) WorkerPoolId() pulumi.StringPtrOutput { return o.ApplyT(func(v *Module) pulumi.StringPtrOutput { return v.WorkerPoolId }).(pulumi.StringPtrOutput) } +// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. +func (o ModuleOutput) WorkflowTool() pulumi.StringOutput { + return o.ApplyT(func(v *Module) pulumi.StringOutput { return v.WorkflowTool }).(pulumi.StringOutput) +} + type ModuleArrayOutput struct{ *pulumi.OutputState } func (ModuleArrayOutput) ElementType() reflect.Type { @@ -500,6 +556,12 @@ func (o ModuleArrayOutput) ToModuleArrayOutputWithContext(ctx context.Context) M return o } +func (o ModuleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Module] { + return pulumix.Output[[]*Module]{ + OutputState: o.OutputState, + } +} + func (o ModuleArrayOutput) Index(i pulumi.IntInput) ModuleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Module { return vs[0].([]*Module)[vs[1].(int)] @@ -520,6 +582,12 @@ func (o ModuleMapOutput) ToModuleMapOutputWithContext(ctx context.Context) Modul return o } +func (o ModuleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Module] { + return pulumix.Output[map[string]*Module]{ + OutputState: o.OutputState, + } +} + func (o ModuleMapOutput) MapIndex(k pulumi.StringInput) ModuleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Module { return vs[0].(map[string]*Module)[vs[1].(string)] diff --git a/sdk/go/spacelift/mountedfile.go b/sdk/go/spacelift/mountedfile.go index 9119f77..600fc00 100644 --- a/sdk/go/spacelift/mountedfile.go +++ b/sdk/go/spacelift/mountedfile.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Mountedfile` represents a file mounted in each Run's workspace that is part of a configuration of a context (`Context`), stack (`Stack`) or a module (`Module`). In principle, it's very similar to an environment variable (`EnvironmentVariable`) except that the value is written to the filesystem rather than passed to the environment. @@ -22,15 +24,15 @@ import ( // // "encoding/base64" // "fmt" -// "io/ioutil" +// "os" // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func filebase64OrPanic(path string) pulumi.StringPtrInput { -// if fileData, err := ioutil.ReadFile(path); err == nil { +// if fileData, err := os.ReadFile(path); err == nil { // return pulumi.String(base64.StdEncoding.EncodeToString(fileData[:])) // } else { // panic(err.Error()) @@ -120,7 +122,14 @@ func NewMountedfile(ctx *pulumi.Context, if args.RelativePath == nil { return nil, errors.New("invalid value for required argument 'RelativePath'") } - opts = pkgResourceDefaultOpts(opts) + if args.Content != nil { + args.Content = pulumi.ToSecret(args.Content).(pulumi.StringInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "content", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) var resource Mountedfile err := ctx.RegisterResource("spacelift:index/mountedfile:Mountedfile", name, args, &resource, opts...) if err != nil { @@ -234,6 +243,12 @@ func (i *Mountedfile) ToMountedfileOutputWithContext(ctx context.Context) Mounte return pulumi.ToOutputWithContext(ctx, i).(MountedfileOutput) } +func (i *Mountedfile) ToOutput(ctx context.Context) pulumix.Output[*Mountedfile] { + return pulumix.Output[*Mountedfile]{ + OutputState: i.ToMountedfileOutputWithContext(ctx).OutputState, + } +} + // MountedfileArrayInput is an input type that accepts MountedfileArray and MountedfileArrayOutput values. // You can construct a concrete instance of `MountedfileArrayInput` via: // @@ -259,6 +274,12 @@ func (i MountedfileArray) ToMountedfileArrayOutputWithContext(ctx context.Contex return pulumi.ToOutputWithContext(ctx, i).(MountedfileArrayOutput) } +func (i MountedfileArray) ToOutput(ctx context.Context) pulumix.Output[[]*Mountedfile] { + return pulumix.Output[[]*Mountedfile]{ + OutputState: i.ToMountedfileArrayOutputWithContext(ctx).OutputState, + } +} + // MountedfileMapInput is an input type that accepts MountedfileMap and MountedfileMapOutput values. // You can construct a concrete instance of `MountedfileMapInput` via: // @@ -284,6 +305,12 @@ func (i MountedfileMap) ToMountedfileMapOutputWithContext(ctx context.Context) M return pulumi.ToOutputWithContext(ctx, i).(MountedfileMapOutput) } +func (i MountedfileMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Mountedfile] { + return pulumix.Output[map[string]*Mountedfile]{ + OutputState: i.ToMountedfileMapOutputWithContext(ctx).OutputState, + } +} + type MountedfileOutput struct{ *pulumi.OutputState } func (MountedfileOutput) ElementType() reflect.Type { @@ -298,6 +325,12 @@ func (o MountedfileOutput) ToMountedfileOutputWithContext(ctx context.Context) M return o } +func (o MountedfileOutput) ToOutput(ctx context.Context) pulumix.Output[*Mountedfile] { + return pulumix.Output[*Mountedfile]{ + OutputState: o.OutputState, + } +} + // SHA-256 checksum of the value func (o MountedfileOutput) Checksum() pulumi.StringOutput { return o.ApplyT(func(v *Mountedfile) pulumi.StringOutput { return v.Checksum }).(pulumi.StringOutput) @@ -347,6 +380,12 @@ func (o MountedfileArrayOutput) ToMountedfileArrayOutputWithContext(ctx context. return o } +func (o MountedfileArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Mountedfile] { + return pulumix.Output[[]*Mountedfile]{ + OutputState: o.OutputState, + } +} + func (o MountedfileArrayOutput) Index(i pulumi.IntInput) MountedfileOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Mountedfile { return vs[0].([]*Mountedfile)[vs[1].(int)] @@ -367,6 +406,12 @@ func (o MountedfileMapOutput) ToMountedfileMapOutputWithContext(ctx context.Cont return o } +func (o MountedfileMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Mountedfile] { + return pulumix.Output[map[string]*Mountedfile]{ + OutputState: o.OutputState, + } +} + func (o MountedfileMapOutput) MapIndex(k pulumi.StringInput) MountedfileOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Mountedfile { return vs[0].(map[string]*Mountedfile)[vs[1].(string)] diff --git a/sdk/go/spacelift/namedWebhook.go b/sdk/go/spacelift/namedWebhook.go new file mode 100644 index 0000000..0a85b4d --- /dev/null +++ b/sdk/go/spacelift/namedWebhook.go @@ -0,0 +1,344 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. +type NamedWebhook struct { + pulumi.CustomResourceState + + // enables or disables sending webhooks. + Enabled pulumi.BoolOutput `pulumi:"enabled"` + // endpoint to send the requests to + Endpoint pulumi.StringOutput `pulumi:"endpoint"` + // labels for the webhook to use when referring in policies or filtering them + Labels pulumi.StringArrayOutput `pulumi:"labels"` + // the name for the webhook which will also be used to generate the id + Name pulumi.StringOutput `pulumi:"name"` + // secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + Secret pulumi.StringPtrOutput `pulumi:"secret"` + // ID of the space the webhook is in + SpaceId pulumi.StringOutput `pulumi:"spaceId"` +} + +// NewNamedWebhook registers a new resource with the given unique name, arguments, and options. +func NewNamedWebhook(ctx *pulumi.Context, + name string, args *NamedWebhookArgs, opts ...pulumi.ResourceOption) (*NamedWebhook, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Enabled == nil { + return nil, errors.New("invalid value for required argument 'Enabled'") + } + if args.Endpoint == nil { + return nil, errors.New("invalid value for required argument 'Endpoint'") + } + if args.SpaceId == nil { + return nil, errors.New("invalid value for required argument 'SpaceId'") + } + if args.Secret != nil { + args.Secret = pulumi.ToSecret(args.Secret).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "secret", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource NamedWebhook + err := ctx.RegisterResource("spacelift:index/namedWebhook:NamedWebhook", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetNamedWebhook gets an existing NamedWebhook resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetNamedWebhook(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *NamedWebhookState, opts ...pulumi.ResourceOption) (*NamedWebhook, error) { + var resource NamedWebhook + err := ctx.ReadResource("spacelift:index/namedWebhook:NamedWebhook", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering NamedWebhook resources. +type namedWebhookState struct { + // enables or disables sending webhooks. + Enabled *bool `pulumi:"enabled"` + // endpoint to send the requests to + Endpoint *string `pulumi:"endpoint"` + // labels for the webhook to use when referring in policies or filtering them + Labels []string `pulumi:"labels"` + // the name for the webhook which will also be used to generate the id + Name *string `pulumi:"name"` + // secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + Secret *string `pulumi:"secret"` + // ID of the space the webhook is in + SpaceId *string `pulumi:"spaceId"` +} + +type NamedWebhookState struct { + // enables or disables sending webhooks. + Enabled pulumi.BoolPtrInput + // endpoint to send the requests to + Endpoint pulumi.StringPtrInput + // labels for the webhook to use when referring in policies or filtering them + Labels pulumi.StringArrayInput + // the name for the webhook which will also be used to generate the id + Name pulumi.StringPtrInput + // secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + Secret pulumi.StringPtrInput + // ID of the space the webhook is in + SpaceId pulumi.StringPtrInput +} + +func (NamedWebhookState) ElementType() reflect.Type { + return reflect.TypeOf((*namedWebhookState)(nil)).Elem() +} + +type namedWebhookArgs struct { + // enables or disables sending webhooks. + Enabled bool `pulumi:"enabled"` + // endpoint to send the requests to + Endpoint string `pulumi:"endpoint"` + // labels for the webhook to use when referring in policies or filtering them + Labels []string `pulumi:"labels"` + // the name for the webhook which will also be used to generate the id + Name *string `pulumi:"name"` + // secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + Secret *string `pulumi:"secret"` + // ID of the space the webhook is in + SpaceId string `pulumi:"spaceId"` +} + +// The set of arguments for constructing a NamedWebhook resource. +type NamedWebhookArgs struct { + // enables or disables sending webhooks. + Enabled pulumi.BoolInput + // endpoint to send the requests to + Endpoint pulumi.StringInput + // labels for the webhook to use when referring in policies or filtering them + Labels pulumi.StringArrayInput + // the name for the webhook which will also be used to generate the id + Name pulumi.StringPtrInput + // secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + Secret pulumi.StringPtrInput + // ID of the space the webhook is in + SpaceId pulumi.StringInput +} + +func (NamedWebhookArgs) ElementType() reflect.Type { + return reflect.TypeOf((*namedWebhookArgs)(nil)).Elem() +} + +type NamedWebhookInput interface { + pulumi.Input + + ToNamedWebhookOutput() NamedWebhookOutput + ToNamedWebhookOutputWithContext(ctx context.Context) NamedWebhookOutput +} + +func (*NamedWebhook) ElementType() reflect.Type { + return reflect.TypeOf((**NamedWebhook)(nil)).Elem() +} + +func (i *NamedWebhook) ToNamedWebhookOutput() NamedWebhookOutput { + return i.ToNamedWebhookOutputWithContext(context.Background()) +} + +func (i *NamedWebhook) ToNamedWebhookOutputWithContext(ctx context.Context) NamedWebhookOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamedWebhookOutput) +} + +func (i *NamedWebhook) ToOutput(ctx context.Context) pulumix.Output[*NamedWebhook] { + return pulumix.Output[*NamedWebhook]{ + OutputState: i.ToNamedWebhookOutputWithContext(ctx).OutputState, + } +} + +// NamedWebhookArrayInput is an input type that accepts NamedWebhookArray and NamedWebhookArrayOutput values. +// You can construct a concrete instance of `NamedWebhookArrayInput` via: +// +// NamedWebhookArray{ NamedWebhookArgs{...} } +type NamedWebhookArrayInput interface { + pulumi.Input + + ToNamedWebhookArrayOutput() NamedWebhookArrayOutput + ToNamedWebhookArrayOutputWithContext(context.Context) NamedWebhookArrayOutput +} + +type NamedWebhookArray []NamedWebhookInput + +func (NamedWebhookArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NamedWebhook)(nil)).Elem() +} + +func (i NamedWebhookArray) ToNamedWebhookArrayOutput() NamedWebhookArrayOutput { + return i.ToNamedWebhookArrayOutputWithContext(context.Background()) +} + +func (i NamedWebhookArray) ToNamedWebhookArrayOutputWithContext(ctx context.Context) NamedWebhookArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamedWebhookArrayOutput) +} + +func (i NamedWebhookArray) ToOutput(ctx context.Context) pulumix.Output[[]*NamedWebhook] { + return pulumix.Output[[]*NamedWebhook]{ + OutputState: i.ToNamedWebhookArrayOutputWithContext(ctx).OutputState, + } +} + +// NamedWebhookMapInput is an input type that accepts NamedWebhookMap and NamedWebhookMapOutput values. +// You can construct a concrete instance of `NamedWebhookMapInput` via: +// +// NamedWebhookMap{ "key": NamedWebhookArgs{...} } +type NamedWebhookMapInput interface { + pulumi.Input + + ToNamedWebhookMapOutput() NamedWebhookMapOutput + ToNamedWebhookMapOutputWithContext(context.Context) NamedWebhookMapOutput +} + +type NamedWebhookMap map[string]NamedWebhookInput + +func (NamedWebhookMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NamedWebhook)(nil)).Elem() +} + +func (i NamedWebhookMap) ToNamedWebhookMapOutput() NamedWebhookMapOutput { + return i.ToNamedWebhookMapOutputWithContext(context.Background()) +} + +func (i NamedWebhookMap) ToNamedWebhookMapOutputWithContext(ctx context.Context) NamedWebhookMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamedWebhookMapOutput) +} + +func (i NamedWebhookMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NamedWebhook] { + return pulumix.Output[map[string]*NamedWebhook]{ + OutputState: i.ToNamedWebhookMapOutputWithContext(ctx).OutputState, + } +} + +type NamedWebhookOutput struct{ *pulumi.OutputState } + +func (NamedWebhookOutput) ElementType() reflect.Type { + return reflect.TypeOf((**NamedWebhook)(nil)).Elem() +} + +func (o NamedWebhookOutput) ToNamedWebhookOutput() NamedWebhookOutput { + return o +} + +func (o NamedWebhookOutput) ToNamedWebhookOutputWithContext(ctx context.Context) NamedWebhookOutput { + return o +} + +func (o NamedWebhookOutput) ToOutput(ctx context.Context) pulumix.Output[*NamedWebhook] { + return pulumix.Output[*NamedWebhook]{ + OutputState: o.OutputState, + } +} + +// enables or disables sending webhooks. +func (o NamedWebhookOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v *NamedWebhook) pulumi.BoolOutput { return v.Enabled }).(pulumi.BoolOutput) +} + +// endpoint to send the requests to +func (o NamedWebhookOutput) Endpoint() pulumi.StringOutput { + return o.ApplyT(func(v *NamedWebhook) pulumi.StringOutput { return v.Endpoint }).(pulumi.StringOutput) +} + +// labels for the webhook to use when referring in policies or filtering them +func (o NamedWebhookOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v *NamedWebhook) pulumi.StringArrayOutput { return v.Labels }).(pulumi.StringArrayOutput) +} + +// the name for the webhook which will also be used to generate the id +func (o NamedWebhookOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *NamedWebhook) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. +func (o NamedWebhookOutput) Secret() pulumi.StringPtrOutput { + return o.ApplyT(func(v *NamedWebhook) pulumi.StringPtrOutput { return v.Secret }).(pulumi.StringPtrOutput) +} + +// ID of the space the webhook is in +func (o NamedWebhookOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v *NamedWebhook) pulumi.StringOutput { return v.SpaceId }).(pulumi.StringOutput) +} + +type NamedWebhookArrayOutput struct{ *pulumi.OutputState } + +func (NamedWebhookArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NamedWebhook)(nil)).Elem() +} + +func (o NamedWebhookArrayOutput) ToNamedWebhookArrayOutput() NamedWebhookArrayOutput { + return o +} + +func (o NamedWebhookArrayOutput) ToNamedWebhookArrayOutputWithContext(ctx context.Context) NamedWebhookArrayOutput { + return o +} + +func (o NamedWebhookArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NamedWebhook] { + return pulumix.Output[[]*NamedWebhook]{ + OutputState: o.OutputState, + } +} + +func (o NamedWebhookArrayOutput) Index(i pulumi.IntInput) NamedWebhookOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NamedWebhook { + return vs[0].([]*NamedWebhook)[vs[1].(int)] + }).(NamedWebhookOutput) +} + +type NamedWebhookMapOutput struct{ *pulumi.OutputState } + +func (NamedWebhookMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NamedWebhook)(nil)).Elem() +} + +func (o NamedWebhookMapOutput) ToNamedWebhookMapOutput() NamedWebhookMapOutput { + return o +} + +func (o NamedWebhookMapOutput) ToNamedWebhookMapOutputWithContext(ctx context.Context) NamedWebhookMapOutput { + return o +} + +func (o NamedWebhookMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NamedWebhook] { + return pulumix.Output[map[string]*NamedWebhook]{ + OutputState: o.OutputState, + } +} + +func (o NamedWebhookMapOutput) MapIndex(k pulumi.StringInput) NamedWebhookOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NamedWebhook { + return vs[0].(map[string]*NamedWebhook)[vs[1].(string)] + }).(NamedWebhookOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*NamedWebhookInput)(nil)).Elem(), &NamedWebhook{}) + pulumi.RegisterInputType(reflect.TypeOf((*NamedWebhookArrayInput)(nil)).Elem(), NamedWebhookArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*NamedWebhookMapInput)(nil)).Elem(), NamedWebhookMap{}) + pulumi.RegisterOutputType(NamedWebhookOutput{}) + pulumi.RegisterOutputType(NamedWebhookArrayOutput{}) + pulumi.RegisterOutputType(NamedWebhookMapOutput{}) +} diff --git a/sdk/go/spacelift/namedWebhookSecretHeader.go b/sdk/go/spacelift/namedWebhookSecretHeader.go new file mode 100644 index 0000000..b3b8921 --- /dev/null +++ b/sdk/go/spacelift/namedWebhookSecretHeader.go @@ -0,0 +1,299 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `NamedWebhookSecretHeader` represents secret key value combination used as a custom headerwhen delivering webhook requests. It depends on `NamedWebhook` resource which should exist. +type NamedWebhookSecretHeader struct { + pulumi.CustomResourceState + + // key for the header + Key pulumi.StringOutput `pulumi:"key"` + // value for the header + Value pulumi.StringOutput `pulumi:"value"` + // ID of the stack on which the environment variable is defined + WebhookId pulumi.StringOutput `pulumi:"webhookId"` +} + +// NewNamedWebhookSecretHeader registers a new resource with the given unique name, arguments, and options. +func NewNamedWebhookSecretHeader(ctx *pulumi.Context, + name string, args *NamedWebhookSecretHeaderArgs, opts ...pulumi.ResourceOption) (*NamedWebhookSecretHeader, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Key == nil { + return nil, errors.New("invalid value for required argument 'Key'") + } + if args.Value == nil { + return nil, errors.New("invalid value for required argument 'Value'") + } + if args.WebhookId == nil { + return nil, errors.New("invalid value for required argument 'WebhookId'") + } + if args.Value != nil { + args.Value = pulumi.ToSecret(args.Value).(pulumi.StringInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "value", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource NamedWebhookSecretHeader + err := ctx.RegisterResource("spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetNamedWebhookSecretHeader gets an existing NamedWebhookSecretHeader resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetNamedWebhookSecretHeader(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *NamedWebhookSecretHeaderState, opts ...pulumi.ResourceOption) (*NamedWebhookSecretHeader, error) { + var resource NamedWebhookSecretHeader + err := ctx.ReadResource("spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering NamedWebhookSecretHeader resources. +type namedWebhookSecretHeaderState struct { + // key for the header + Key *string `pulumi:"key"` + // value for the header + Value *string `pulumi:"value"` + // ID of the stack on which the environment variable is defined + WebhookId *string `pulumi:"webhookId"` +} + +type NamedWebhookSecretHeaderState struct { + // key for the header + Key pulumi.StringPtrInput + // value for the header + Value pulumi.StringPtrInput + // ID of the stack on which the environment variable is defined + WebhookId pulumi.StringPtrInput +} + +func (NamedWebhookSecretHeaderState) ElementType() reflect.Type { + return reflect.TypeOf((*namedWebhookSecretHeaderState)(nil)).Elem() +} + +type namedWebhookSecretHeaderArgs struct { + // key for the header + Key string `pulumi:"key"` + // value for the header + Value string `pulumi:"value"` + // ID of the stack on which the environment variable is defined + WebhookId string `pulumi:"webhookId"` +} + +// The set of arguments for constructing a NamedWebhookSecretHeader resource. +type NamedWebhookSecretHeaderArgs struct { + // key for the header + Key pulumi.StringInput + // value for the header + Value pulumi.StringInput + // ID of the stack on which the environment variable is defined + WebhookId pulumi.StringInput +} + +func (NamedWebhookSecretHeaderArgs) ElementType() reflect.Type { + return reflect.TypeOf((*namedWebhookSecretHeaderArgs)(nil)).Elem() +} + +type NamedWebhookSecretHeaderInput interface { + pulumi.Input + + ToNamedWebhookSecretHeaderOutput() NamedWebhookSecretHeaderOutput + ToNamedWebhookSecretHeaderOutputWithContext(ctx context.Context) NamedWebhookSecretHeaderOutput +} + +func (*NamedWebhookSecretHeader) ElementType() reflect.Type { + return reflect.TypeOf((**NamedWebhookSecretHeader)(nil)).Elem() +} + +func (i *NamedWebhookSecretHeader) ToNamedWebhookSecretHeaderOutput() NamedWebhookSecretHeaderOutput { + return i.ToNamedWebhookSecretHeaderOutputWithContext(context.Background()) +} + +func (i *NamedWebhookSecretHeader) ToNamedWebhookSecretHeaderOutputWithContext(ctx context.Context) NamedWebhookSecretHeaderOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamedWebhookSecretHeaderOutput) +} + +func (i *NamedWebhookSecretHeader) ToOutput(ctx context.Context) pulumix.Output[*NamedWebhookSecretHeader] { + return pulumix.Output[*NamedWebhookSecretHeader]{ + OutputState: i.ToNamedWebhookSecretHeaderOutputWithContext(ctx).OutputState, + } +} + +// NamedWebhookSecretHeaderArrayInput is an input type that accepts NamedWebhookSecretHeaderArray and NamedWebhookSecretHeaderArrayOutput values. +// You can construct a concrete instance of `NamedWebhookSecretHeaderArrayInput` via: +// +// NamedWebhookSecretHeaderArray{ NamedWebhookSecretHeaderArgs{...} } +type NamedWebhookSecretHeaderArrayInput interface { + pulumi.Input + + ToNamedWebhookSecretHeaderArrayOutput() NamedWebhookSecretHeaderArrayOutput + ToNamedWebhookSecretHeaderArrayOutputWithContext(context.Context) NamedWebhookSecretHeaderArrayOutput +} + +type NamedWebhookSecretHeaderArray []NamedWebhookSecretHeaderInput + +func (NamedWebhookSecretHeaderArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NamedWebhookSecretHeader)(nil)).Elem() +} + +func (i NamedWebhookSecretHeaderArray) ToNamedWebhookSecretHeaderArrayOutput() NamedWebhookSecretHeaderArrayOutput { + return i.ToNamedWebhookSecretHeaderArrayOutputWithContext(context.Background()) +} + +func (i NamedWebhookSecretHeaderArray) ToNamedWebhookSecretHeaderArrayOutputWithContext(ctx context.Context) NamedWebhookSecretHeaderArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamedWebhookSecretHeaderArrayOutput) +} + +func (i NamedWebhookSecretHeaderArray) ToOutput(ctx context.Context) pulumix.Output[[]*NamedWebhookSecretHeader] { + return pulumix.Output[[]*NamedWebhookSecretHeader]{ + OutputState: i.ToNamedWebhookSecretHeaderArrayOutputWithContext(ctx).OutputState, + } +} + +// NamedWebhookSecretHeaderMapInput is an input type that accepts NamedWebhookSecretHeaderMap and NamedWebhookSecretHeaderMapOutput values. +// You can construct a concrete instance of `NamedWebhookSecretHeaderMapInput` via: +// +// NamedWebhookSecretHeaderMap{ "key": NamedWebhookSecretHeaderArgs{...} } +type NamedWebhookSecretHeaderMapInput interface { + pulumi.Input + + ToNamedWebhookSecretHeaderMapOutput() NamedWebhookSecretHeaderMapOutput + ToNamedWebhookSecretHeaderMapOutputWithContext(context.Context) NamedWebhookSecretHeaderMapOutput +} + +type NamedWebhookSecretHeaderMap map[string]NamedWebhookSecretHeaderInput + +func (NamedWebhookSecretHeaderMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NamedWebhookSecretHeader)(nil)).Elem() +} + +func (i NamedWebhookSecretHeaderMap) ToNamedWebhookSecretHeaderMapOutput() NamedWebhookSecretHeaderMapOutput { + return i.ToNamedWebhookSecretHeaderMapOutputWithContext(context.Background()) +} + +func (i NamedWebhookSecretHeaderMap) ToNamedWebhookSecretHeaderMapOutputWithContext(ctx context.Context) NamedWebhookSecretHeaderMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(NamedWebhookSecretHeaderMapOutput) +} + +func (i NamedWebhookSecretHeaderMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NamedWebhookSecretHeader] { + return pulumix.Output[map[string]*NamedWebhookSecretHeader]{ + OutputState: i.ToNamedWebhookSecretHeaderMapOutputWithContext(ctx).OutputState, + } +} + +type NamedWebhookSecretHeaderOutput struct{ *pulumi.OutputState } + +func (NamedWebhookSecretHeaderOutput) ElementType() reflect.Type { + return reflect.TypeOf((**NamedWebhookSecretHeader)(nil)).Elem() +} + +func (o NamedWebhookSecretHeaderOutput) ToNamedWebhookSecretHeaderOutput() NamedWebhookSecretHeaderOutput { + return o +} + +func (o NamedWebhookSecretHeaderOutput) ToNamedWebhookSecretHeaderOutputWithContext(ctx context.Context) NamedWebhookSecretHeaderOutput { + return o +} + +func (o NamedWebhookSecretHeaderOutput) ToOutput(ctx context.Context) pulumix.Output[*NamedWebhookSecretHeader] { + return pulumix.Output[*NamedWebhookSecretHeader]{ + OutputState: o.OutputState, + } +} + +// key for the header +func (o NamedWebhookSecretHeaderOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v *NamedWebhookSecretHeader) pulumi.StringOutput { return v.Key }).(pulumi.StringOutput) +} + +// value for the header +func (o NamedWebhookSecretHeaderOutput) Value() pulumi.StringOutput { + return o.ApplyT(func(v *NamedWebhookSecretHeader) pulumi.StringOutput { return v.Value }).(pulumi.StringOutput) +} + +// ID of the stack on which the environment variable is defined +func (o NamedWebhookSecretHeaderOutput) WebhookId() pulumi.StringOutput { + return o.ApplyT(func(v *NamedWebhookSecretHeader) pulumi.StringOutput { return v.WebhookId }).(pulumi.StringOutput) +} + +type NamedWebhookSecretHeaderArrayOutput struct{ *pulumi.OutputState } + +func (NamedWebhookSecretHeaderArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NamedWebhookSecretHeader)(nil)).Elem() +} + +func (o NamedWebhookSecretHeaderArrayOutput) ToNamedWebhookSecretHeaderArrayOutput() NamedWebhookSecretHeaderArrayOutput { + return o +} + +func (o NamedWebhookSecretHeaderArrayOutput) ToNamedWebhookSecretHeaderArrayOutputWithContext(ctx context.Context) NamedWebhookSecretHeaderArrayOutput { + return o +} + +func (o NamedWebhookSecretHeaderArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*NamedWebhookSecretHeader] { + return pulumix.Output[[]*NamedWebhookSecretHeader]{ + OutputState: o.OutputState, + } +} + +func (o NamedWebhookSecretHeaderArrayOutput) Index(i pulumi.IntInput) NamedWebhookSecretHeaderOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NamedWebhookSecretHeader { + return vs[0].([]*NamedWebhookSecretHeader)[vs[1].(int)] + }).(NamedWebhookSecretHeaderOutput) +} + +type NamedWebhookSecretHeaderMapOutput struct{ *pulumi.OutputState } + +func (NamedWebhookSecretHeaderMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NamedWebhookSecretHeader)(nil)).Elem() +} + +func (o NamedWebhookSecretHeaderMapOutput) ToNamedWebhookSecretHeaderMapOutput() NamedWebhookSecretHeaderMapOutput { + return o +} + +func (o NamedWebhookSecretHeaderMapOutput) ToNamedWebhookSecretHeaderMapOutputWithContext(ctx context.Context) NamedWebhookSecretHeaderMapOutput { + return o +} + +func (o NamedWebhookSecretHeaderMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*NamedWebhookSecretHeader] { + return pulumix.Output[map[string]*NamedWebhookSecretHeader]{ + OutputState: o.OutputState, + } +} + +func (o NamedWebhookSecretHeaderMapOutput) MapIndex(k pulumi.StringInput) NamedWebhookSecretHeaderOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NamedWebhookSecretHeader { + return vs[0].(map[string]*NamedWebhookSecretHeader)[vs[1].(string)] + }).(NamedWebhookSecretHeaderOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*NamedWebhookSecretHeaderInput)(nil)).Elem(), &NamedWebhookSecretHeader{}) + pulumi.RegisterInputType(reflect.TypeOf((*NamedWebhookSecretHeaderArrayInput)(nil)).Elem(), NamedWebhookSecretHeaderArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*NamedWebhookSecretHeaderMapInput)(nil)).Elem(), NamedWebhookSecretHeaderMap{}) + pulumi.RegisterOutputType(NamedWebhookSecretHeaderOutput{}) + pulumi.RegisterOutputType(NamedWebhookSecretHeaderArrayOutput{}) + pulumi.RegisterOutputType(NamedWebhookSecretHeaderMapOutput{}) +} diff --git a/sdk/go/spacelift/policy.go b/sdk/go/spacelift/policy.go index bbea378..d285fbf 100644 --- a/sdk/go/spacelift/policy.go +++ b/sdk/go/spacelift/policy.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Policy` represents a Spacelift **policy** - a collection of customer-defined rules that are applied by Spacelift at one of the decision points within the application. @@ -21,15 +23,15 @@ import ( // import ( // // "fmt" -// "io/ioutil" +// "os" // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func readFileOrPanic(path string) pulumi.StringPtrInput { -// data, err := ioutil.ReadFile(path) +// data, err := os.ReadFile(path) // if err != nil { // panic(err.Error()) // } @@ -82,7 +84,7 @@ type Policy struct { Name pulumi.StringOutput `pulumi:"name"` // ID (slug) of the space the policy is in SpaceId pulumi.StringOutput `pulumi:"spaceId"` - // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). Type pulumi.StringOutput `pulumi:"type"` } @@ -99,7 +101,7 @@ func NewPolicy(ctx *pulumi.Context, if args.Type == nil { return nil, errors.New("invalid value for required argument 'Type'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource Policy err := ctx.RegisterResource("spacelift:index/policy:Policy", name, args, &resource, opts...) if err != nil { @@ -129,7 +131,7 @@ type policyState struct { Name *string `pulumi:"name"` // ID (slug) of the space the policy is in SpaceId *string `pulumi:"spaceId"` - // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). Type *string `pulumi:"type"` } @@ -141,7 +143,7 @@ type PolicyState struct { Name pulumi.StringPtrInput // ID (slug) of the space the policy is in SpaceId pulumi.StringPtrInput - // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). Type pulumi.StringPtrInput } @@ -157,7 +159,7 @@ type policyArgs struct { Name *string `pulumi:"name"` // ID (slug) of the space the policy is in SpaceId *string `pulumi:"spaceId"` - // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). Type string `pulumi:"type"` } @@ -170,7 +172,7 @@ type PolicyArgs struct { Name pulumi.StringPtrInput // ID (slug) of the space the policy is in SpaceId pulumi.StringPtrInput - // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + // Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). Type pulumi.StringInput } @@ -197,6 +199,12 @@ func (i *Policy) ToPolicyOutputWithContext(ctx context.Context) PolicyOutput { return pulumi.ToOutputWithContext(ctx, i).(PolicyOutput) } +func (i *Policy) ToOutput(ctx context.Context) pulumix.Output[*Policy] { + return pulumix.Output[*Policy]{ + OutputState: i.ToPolicyOutputWithContext(ctx).OutputState, + } +} + // PolicyArrayInput is an input type that accepts PolicyArray and PolicyArrayOutput values. // You can construct a concrete instance of `PolicyArrayInput` via: // @@ -222,6 +230,12 @@ func (i PolicyArray) ToPolicyArrayOutputWithContext(ctx context.Context) PolicyA return pulumi.ToOutputWithContext(ctx, i).(PolicyArrayOutput) } +func (i PolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]*Policy] { + return pulumix.Output[[]*Policy]{ + OutputState: i.ToPolicyArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyMapInput is an input type that accepts PolicyMap and PolicyMapOutput values. // You can construct a concrete instance of `PolicyMapInput` via: // @@ -247,6 +261,12 @@ func (i PolicyMap) ToPolicyMapOutputWithContext(ctx context.Context) PolicyMapOu return pulumi.ToOutputWithContext(ctx, i).(PolicyMapOutput) } +func (i PolicyMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Policy] { + return pulumix.Output[map[string]*Policy]{ + OutputState: i.ToPolicyMapOutputWithContext(ctx).OutputState, + } +} + type PolicyOutput struct{ *pulumi.OutputState } func (PolicyOutput) ElementType() reflect.Type { @@ -261,6 +281,12 @@ func (o PolicyOutput) ToPolicyOutputWithContext(ctx context.Context) PolicyOutpu return o } +func (o PolicyOutput) ToOutput(ctx context.Context) pulumix.Output[*Policy] { + return pulumix.Output[*Policy]{ + OutputState: o.OutputState, + } +} + // Body of the policy func (o PolicyOutput) Body() pulumi.StringOutput { return o.ApplyT(func(v *Policy) pulumi.StringOutput { return v.Body }).(pulumi.StringOutput) @@ -280,7 +306,7 @@ func (o PolicyOutput) SpaceId() pulumi.StringOutput { return o.ApplyT(func(v *Policy) pulumi.StringOutput { return v.SpaceId }).(pulumi.StringOutput) } -// Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). +// Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). func (o PolicyOutput) Type() pulumi.StringOutput { return o.ApplyT(func(v *Policy) pulumi.StringOutput { return v.Type }).(pulumi.StringOutput) } @@ -299,6 +325,12 @@ func (o PolicyArrayOutput) ToPolicyArrayOutputWithContext(ctx context.Context) P return o } +func (o PolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Policy] { + return pulumix.Output[[]*Policy]{ + OutputState: o.OutputState, + } +} + func (o PolicyArrayOutput) Index(i pulumi.IntInput) PolicyOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Policy { return vs[0].([]*Policy)[vs[1].(int)] @@ -319,6 +351,12 @@ func (o PolicyMapOutput) ToPolicyMapOutputWithContext(ctx context.Context) Polic return o } +func (o PolicyMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Policy] { + return pulumix.Output[map[string]*Policy]{ + OutputState: o.OutputState, + } +} + func (o PolicyMapOutput) MapIndex(k pulumi.StringInput) PolicyOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Policy { return vs[0].(map[string]*Policy)[vs[1].(string)] diff --git a/sdk/go/spacelift/policyAttachment.go b/sdk/go/spacelift/policyAttachment.go index df6b821..a3f957e 100644 --- a/sdk/go/spacelift/policyAttachment.go +++ b/sdk/go/spacelift/policyAttachment.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `PolicyAttachment` represents a relationship between a policy (`Policy`) and a stack (`Stack`) or module (`Module`). Each policy can only be attached to a stack/module once. `LOGIN` policies are the exception because they apply globally and not to individual stacks/modules. An attempt to attach one will fail. @@ -20,15 +22,15 @@ import ( // // import ( // -// "io/ioutil" +// "os" // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func readFileOrPanic(path string) pulumi.StringPtrInput { -// data, err := ioutil.ReadFile(path) +// data, err := os.ReadFile(path) // if err != nil { // panic(err.Error()) // } @@ -92,7 +94,7 @@ func NewPolicyAttachment(ctx *pulumi.Context, if args.PolicyId == nil { return nil, errors.New("invalid value for required argument 'PolicyId'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource PolicyAttachment err := ctx.RegisterResource("spacelift:index/policyAttachment:PolicyAttachment", name, args, &resource, opts...) if err != nil { @@ -178,6 +180,12 @@ func (i *PolicyAttachment) ToPolicyAttachmentOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(PolicyAttachmentOutput) } +func (i *PolicyAttachment) ToOutput(ctx context.Context) pulumix.Output[*PolicyAttachment] { + return pulumix.Output[*PolicyAttachment]{ + OutputState: i.ToPolicyAttachmentOutputWithContext(ctx).OutputState, + } +} + // PolicyAttachmentArrayInput is an input type that accepts PolicyAttachmentArray and PolicyAttachmentArrayOutput values. // You can construct a concrete instance of `PolicyAttachmentArrayInput` via: // @@ -203,6 +211,12 @@ func (i PolicyAttachmentArray) ToPolicyAttachmentArrayOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(PolicyAttachmentArrayOutput) } +func (i PolicyAttachmentArray) ToOutput(ctx context.Context) pulumix.Output[[]*PolicyAttachment] { + return pulumix.Output[[]*PolicyAttachment]{ + OutputState: i.ToPolicyAttachmentArrayOutputWithContext(ctx).OutputState, + } +} + // PolicyAttachmentMapInput is an input type that accepts PolicyAttachmentMap and PolicyAttachmentMapOutput values. // You can construct a concrete instance of `PolicyAttachmentMapInput` via: // @@ -228,6 +242,12 @@ func (i PolicyAttachmentMap) ToPolicyAttachmentMapOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(PolicyAttachmentMapOutput) } +func (i PolicyAttachmentMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*PolicyAttachment] { + return pulumix.Output[map[string]*PolicyAttachment]{ + OutputState: i.ToPolicyAttachmentMapOutputWithContext(ctx).OutputState, + } +} + type PolicyAttachmentOutput struct{ *pulumi.OutputState } func (PolicyAttachmentOutput) ElementType() reflect.Type { @@ -242,6 +262,12 @@ func (o PolicyAttachmentOutput) ToPolicyAttachmentOutputWithContext(ctx context. return o } +func (o PolicyAttachmentOutput) ToOutput(ctx context.Context) pulumix.Output[*PolicyAttachment] { + return pulumix.Output[*PolicyAttachment]{ + OutputState: o.OutputState, + } +} + // ID of the module to attach the policy to func (o PolicyAttachmentOutput) ModuleId() pulumi.StringPtrOutput { return o.ApplyT(func(v *PolicyAttachment) pulumi.StringPtrOutput { return v.ModuleId }).(pulumi.StringPtrOutput) @@ -271,6 +297,12 @@ func (o PolicyAttachmentArrayOutput) ToPolicyAttachmentArrayOutputWithContext(ct return o } +func (o PolicyAttachmentArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*PolicyAttachment] { + return pulumix.Output[[]*PolicyAttachment]{ + OutputState: o.OutputState, + } +} + func (o PolicyAttachmentArrayOutput) Index(i pulumi.IntInput) PolicyAttachmentOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PolicyAttachment { return vs[0].([]*PolicyAttachment)[vs[1].(int)] @@ -291,6 +323,12 @@ func (o PolicyAttachmentMapOutput) ToPolicyAttachmentMapOutputWithContext(ctx co return o } +func (o PolicyAttachmentMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*PolicyAttachment] { + return pulumix.Output[map[string]*PolicyAttachment]{ + OutputState: o.OutputState, + } +} + func (o PolicyAttachmentMapOutput) MapIndex(k pulumi.StringInput) PolicyAttachmentOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PolicyAttachment { return vs[0].(map[string]*PolicyAttachment)[vs[1].(string)] diff --git a/sdk/go/spacelift/provider.go b/sdk/go/spacelift/provider.go index 214f411..0cecf62 100644 --- a/sdk/go/spacelift/provider.go +++ b/sdk/go/spacelift/provider.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // The provider type for the spacelift package. By default, resources use package-wide configuration @@ -34,30 +36,38 @@ func NewProvider(ctx *pulumi.Context, args = &ProviderArgs{} } - if isZero(args.ApiKeyEndpoint) { - args.ApiKeyEndpoint = pulumi.StringPtr(getEnvOrDefault("", nil, "SPACELIFT_API_KEY_ENDPOINT").(string)) + if args.ApiKeyEndpoint == nil { + if d := internal.GetEnvOrDefault(nil, nil, "SPACELIFT_API_KEY_ENDPOINT"); d != nil { + args.ApiKeyEndpoint = pulumi.StringPtr(d.(string)) + } } - if isZero(args.ApiKeyId) { - args.ApiKeyId = pulumi.StringPtr(getEnvOrDefault("", nil, "SPACELIFT_API_KEY_ID").(string)) + if args.ApiKeyId == nil { + if d := internal.GetEnvOrDefault(nil, nil, "SPACELIFT_API_KEY_ID"); d != nil { + args.ApiKeyId = pulumi.StringPtr(d.(string)) + } } - if isZero(args.ApiKeySecret) { - args.ApiKeySecret = pulumi.StringPtr(getEnvOrDefault("", nil, "SPACELIFT_API_KEY_SECRET").(string)) + if args.ApiKeySecret == nil { + if d := internal.GetEnvOrDefault(nil, nil, "SPACELIFT_API_KEY_SECRET"); d != nil { + args.ApiKeySecret = pulumi.StringPtr(d.(string)) + } } - if isZero(args.ApiToken) { - args.ApiToken = pulumi.StringPtr(getEnvOrDefault("", nil, "SPACELIFT_API_TOKEN").(string)) + if args.ApiToken == nil { + if d := internal.GetEnvOrDefault(nil, nil, "SPACELIFT_API_TOKEN"); d != nil { + args.ApiToken = pulumi.StringPtr(d.(string)) + } } if args.ApiKeySecret != nil { - args.ApiKeySecret = pulumi.ToSecret(args.ApiKeySecret).(pulumi.StringPtrOutput) + args.ApiKeySecret = pulumi.ToSecret(args.ApiKeySecret).(pulumi.StringPtrInput) } if args.ApiToken != nil { - args.ApiToken = pulumi.ToSecret(args.ApiToken).(pulumi.StringPtrOutput) + args.ApiToken = pulumi.ToSecret(args.ApiToken).(pulumi.StringPtrInput) } secrets := pulumi.AdditionalSecretOutputs([]string{ "apiKeySecret", "apiToken", }) opts = append(opts, secrets) - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource Provider err := ctx.RegisterResource("pulumi:providers:spacelift", name, args, &resource, opts...) if err != nil { @@ -112,6 +122,12 @@ func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutp return pulumi.ToOutputWithContext(ctx, i).(ProviderOutput) } +func (i *Provider) ToOutput(ctx context.Context) pulumix.Output[*Provider] { + return pulumix.Output[*Provider]{ + OutputState: i.ToProviderOutputWithContext(ctx).OutputState, + } +} + type ProviderOutput struct{ *pulumi.OutputState } func (ProviderOutput) ElementType() reflect.Type { @@ -126,6 +142,12 @@ func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) Provide return o } +func (o ProviderOutput) ToOutput(ctx context.Context) pulumix.Output[*Provider] { + return pulumix.Output[*Provider]{ + OutputState: o.OutputState, + } +} + // Endpoint to use when authenticating with an API key outside of Spacelift func (o ProviderOutput) ApiKeyEndpoint() pulumi.StringPtrOutput { return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ApiKeyEndpoint }).(pulumi.StringPtrOutput) diff --git a/sdk/go/spacelift/pulumiTypes.go b/sdk/go/spacelift/pulumiTypes.go index f211b56..25f7e97 100644 --- a/sdk/go/spacelift/pulumiTypes.go +++ b/sdk/go/spacelift/pulumiTypes.go @@ -8,8 +8,142 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) +var _ = internal.GetEnvOrDefault + +type IdpGroupMappingPolicy struct { + // Type of access to the space. Possible values are: READ, WRITE, ADMIN + Role string `pulumi:"role"` + // ID (slug) of the space the user group has access to + SpaceId string `pulumi:"spaceId"` +} + +// IdpGroupMappingPolicyInput is an input type that accepts IdpGroupMappingPolicyArgs and IdpGroupMappingPolicyOutput values. +// You can construct a concrete instance of `IdpGroupMappingPolicyInput` via: +// +// IdpGroupMappingPolicyArgs{...} +type IdpGroupMappingPolicyInput interface { + pulumi.Input + + ToIdpGroupMappingPolicyOutput() IdpGroupMappingPolicyOutput + ToIdpGroupMappingPolicyOutputWithContext(context.Context) IdpGroupMappingPolicyOutput +} + +type IdpGroupMappingPolicyArgs struct { + // Type of access to the space. Possible values are: READ, WRITE, ADMIN + Role pulumi.StringInput `pulumi:"role"` + // ID (slug) of the space the user group has access to + SpaceId pulumi.StringInput `pulumi:"spaceId"` +} + +func (IdpGroupMappingPolicyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*IdpGroupMappingPolicy)(nil)).Elem() +} + +func (i IdpGroupMappingPolicyArgs) ToIdpGroupMappingPolicyOutput() IdpGroupMappingPolicyOutput { + return i.ToIdpGroupMappingPolicyOutputWithContext(context.Background()) +} + +func (i IdpGroupMappingPolicyArgs) ToIdpGroupMappingPolicyOutputWithContext(ctx context.Context) IdpGroupMappingPolicyOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdpGroupMappingPolicyOutput) +} + +func (i IdpGroupMappingPolicyArgs) ToOutput(ctx context.Context) pulumix.Output[IdpGroupMappingPolicy] { + return pulumix.Output[IdpGroupMappingPolicy]{ + OutputState: i.ToIdpGroupMappingPolicyOutputWithContext(ctx).OutputState, + } +} + +// IdpGroupMappingPolicyArrayInput is an input type that accepts IdpGroupMappingPolicyArray and IdpGroupMappingPolicyArrayOutput values. +// You can construct a concrete instance of `IdpGroupMappingPolicyArrayInput` via: +// +// IdpGroupMappingPolicyArray{ IdpGroupMappingPolicyArgs{...} } +type IdpGroupMappingPolicyArrayInput interface { + pulumi.Input + + ToIdpGroupMappingPolicyArrayOutput() IdpGroupMappingPolicyArrayOutput + ToIdpGroupMappingPolicyArrayOutputWithContext(context.Context) IdpGroupMappingPolicyArrayOutput +} + +type IdpGroupMappingPolicyArray []IdpGroupMappingPolicyInput + +func (IdpGroupMappingPolicyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]IdpGroupMappingPolicy)(nil)).Elem() +} + +func (i IdpGroupMappingPolicyArray) ToIdpGroupMappingPolicyArrayOutput() IdpGroupMappingPolicyArrayOutput { + return i.ToIdpGroupMappingPolicyArrayOutputWithContext(context.Background()) +} + +func (i IdpGroupMappingPolicyArray) ToIdpGroupMappingPolicyArrayOutputWithContext(ctx context.Context) IdpGroupMappingPolicyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(IdpGroupMappingPolicyArrayOutput) +} + +func (i IdpGroupMappingPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]IdpGroupMappingPolicy] { + return pulumix.Output[[]IdpGroupMappingPolicy]{ + OutputState: i.ToIdpGroupMappingPolicyArrayOutputWithContext(ctx).OutputState, + } +} + +type IdpGroupMappingPolicyOutput struct{ *pulumi.OutputState } + +func (IdpGroupMappingPolicyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IdpGroupMappingPolicy)(nil)).Elem() +} + +func (o IdpGroupMappingPolicyOutput) ToIdpGroupMappingPolicyOutput() IdpGroupMappingPolicyOutput { + return o +} + +func (o IdpGroupMappingPolicyOutput) ToIdpGroupMappingPolicyOutputWithContext(ctx context.Context) IdpGroupMappingPolicyOutput { + return o +} + +func (o IdpGroupMappingPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[IdpGroupMappingPolicy] { + return pulumix.Output[IdpGroupMappingPolicy]{ + OutputState: o.OutputState, + } +} + +// Type of access to the space. Possible values are: READ, WRITE, ADMIN +func (o IdpGroupMappingPolicyOutput) Role() pulumi.StringOutput { + return o.ApplyT(func(v IdpGroupMappingPolicy) string { return v.Role }).(pulumi.StringOutput) +} + +// ID (slug) of the space the user group has access to +func (o IdpGroupMappingPolicyOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v IdpGroupMappingPolicy) string { return v.SpaceId }).(pulumi.StringOutput) +} + +type IdpGroupMappingPolicyArrayOutput struct{ *pulumi.OutputState } + +func (IdpGroupMappingPolicyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]IdpGroupMappingPolicy)(nil)).Elem() +} + +func (o IdpGroupMappingPolicyArrayOutput) ToIdpGroupMappingPolicyArrayOutput() IdpGroupMappingPolicyArrayOutput { + return o +} + +func (o IdpGroupMappingPolicyArrayOutput) ToIdpGroupMappingPolicyArrayOutputWithContext(ctx context.Context) IdpGroupMappingPolicyArrayOutput { + return o +} + +func (o IdpGroupMappingPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]IdpGroupMappingPolicy] { + return pulumix.Output[[]IdpGroupMappingPolicy]{ + OutputState: o.OutputState, + } +} + +func (o IdpGroupMappingPolicyArrayOutput) Index(i pulumi.IntInput) IdpGroupMappingPolicyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) IdpGroupMappingPolicy { + return vs[0].([]IdpGroupMappingPolicy)[vs[1].(int)] + }).(IdpGroupMappingPolicyOutput) +} + type ModuleAzureDevops struct { // The name of the Azure DevOps project Project string `pulumi:"project"` @@ -43,6 +177,12 @@ func (i ModuleAzureDevopsArgs) ToModuleAzureDevopsOutputWithContext(ctx context. return pulumi.ToOutputWithContext(ctx, i).(ModuleAzureDevopsOutput) } +func (i ModuleAzureDevopsArgs) ToOutput(ctx context.Context) pulumix.Output[ModuleAzureDevops] { + return pulumix.Output[ModuleAzureDevops]{ + OutputState: i.ToModuleAzureDevopsOutputWithContext(ctx).OutputState, + } +} + func (i ModuleAzureDevopsArgs) ToModuleAzureDevopsPtrOutput() ModuleAzureDevopsPtrOutput { return i.ToModuleAzureDevopsPtrOutputWithContext(context.Background()) } @@ -84,6 +224,12 @@ func (i *moduleAzureDevopsPtrType) ToModuleAzureDevopsPtrOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(ModuleAzureDevopsPtrOutput) } +func (i *moduleAzureDevopsPtrType) ToOutput(ctx context.Context) pulumix.Output[*ModuleAzureDevops] { + return pulumix.Output[*ModuleAzureDevops]{ + OutputState: i.ToModuleAzureDevopsPtrOutputWithContext(ctx).OutputState, + } +} + type ModuleAzureDevopsOutput struct{ *pulumi.OutputState } func (ModuleAzureDevopsOutput) ElementType() reflect.Type { @@ -108,6 +254,12 @@ func (o ModuleAzureDevopsOutput) ToModuleAzureDevopsPtrOutputWithContext(ctx con }).(ModuleAzureDevopsPtrOutput) } +func (o ModuleAzureDevopsOutput) ToOutput(ctx context.Context) pulumix.Output[ModuleAzureDevops] { + return pulumix.Output[ModuleAzureDevops]{ + OutputState: o.OutputState, + } +} + // The name of the Azure DevOps project func (o ModuleAzureDevopsOutput) Project() pulumi.StringOutput { return o.ApplyT(func(v ModuleAzureDevops) string { return v.Project }).(pulumi.StringOutput) @@ -127,6 +279,12 @@ func (o ModuleAzureDevopsPtrOutput) ToModuleAzureDevopsPtrOutputWithContext(ctx return o } +func (o ModuleAzureDevopsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ModuleAzureDevops] { + return pulumix.Output[*ModuleAzureDevops]{ + OutputState: o.OutputState, + } +} + func (o ModuleAzureDevopsPtrOutput) Elem() ModuleAzureDevopsOutput { return o.ApplyT(func(v *ModuleAzureDevops) ModuleAzureDevops { if v != nil { @@ -180,6 +338,12 @@ func (i ModuleBitbucketCloudArgs) ToModuleBitbucketCloudOutputWithContext(ctx co return pulumi.ToOutputWithContext(ctx, i).(ModuleBitbucketCloudOutput) } +func (i ModuleBitbucketCloudArgs) ToOutput(ctx context.Context) pulumix.Output[ModuleBitbucketCloud] { + return pulumix.Output[ModuleBitbucketCloud]{ + OutputState: i.ToModuleBitbucketCloudOutputWithContext(ctx).OutputState, + } +} + func (i ModuleBitbucketCloudArgs) ToModuleBitbucketCloudPtrOutput() ModuleBitbucketCloudPtrOutput { return i.ToModuleBitbucketCloudPtrOutputWithContext(context.Background()) } @@ -221,6 +385,12 @@ func (i *moduleBitbucketCloudPtrType) ToModuleBitbucketCloudPtrOutputWithContext return pulumi.ToOutputWithContext(ctx, i).(ModuleBitbucketCloudPtrOutput) } +func (i *moduleBitbucketCloudPtrType) ToOutput(ctx context.Context) pulumix.Output[*ModuleBitbucketCloud] { + return pulumix.Output[*ModuleBitbucketCloud]{ + OutputState: i.ToModuleBitbucketCloudPtrOutputWithContext(ctx).OutputState, + } +} + type ModuleBitbucketCloudOutput struct{ *pulumi.OutputState } func (ModuleBitbucketCloudOutput) ElementType() reflect.Type { @@ -245,6 +415,12 @@ func (o ModuleBitbucketCloudOutput) ToModuleBitbucketCloudPtrOutputWithContext(c }).(ModuleBitbucketCloudPtrOutput) } +func (o ModuleBitbucketCloudOutput) ToOutput(ctx context.Context) pulumix.Output[ModuleBitbucketCloud] { + return pulumix.Output[ModuleBitbucketCloud]{ + OutputState: o.OutputState, + } +} + // The Bitbucket project containing the repository func (o ModuleBitbucketCloudOutput) Namespace() pulumi.StringOutput { return o.ApplyT(func(v ModuleBitbucketCloud) string { return v.Namespace }).(pulumi.StringOutput) @@ -264,6 +440,12 @@ func (o ModuleBitbucketCloudPtrOutput) ToModuleBitbucketCloudPtrOutputWithContex return o } +func (o ModuleBitbucketCloudPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ModuleBitbucketCloud] { + return pulumix.Output[*ModuleBitbucketCloud]{ + OutputState: o.OutputState, + } +} + func (o ModuleBitbucketCloudPtrOutput) Elem() ModuleBitbucketCloudOutput { return o.ApplyT(func(v *ModuleBitbucketCloud) ModuleBitbucketCloud { if v != nil { @@ -317,6 +499,12 @@ func (i ModuleBitbucketDatacenterArgs) ToModuleBitbucketDatacenterOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(ModuleBitbucketDatacenterOutput) } +func (i ModuleBitbucketDatacenterArgs) ToOutput(ctx context.Context) pulumix.Output[ModuleBitbucketDatacenter] { + return pulumix.Output[ModuleBitbucketDatacenter]{ + OutputState: i.ToModuleBitbucketDatacenterOutputWithContext(ctx).OutputState, + } +} + func (i ModuleBitbucketDatacenterArgs) ToModuleBitbucketDatacenterPtrOutput() ModuleBitbucketDatacenterPtrOutput { return i.ToModuleBitbucketDatacenterPtrOutputWithContext(context.Background()) } @@ -358,6 +546,12 @@ func (i *moduleBitbucketDatacenterPtrType) ToModuleBitbucketDatacenterPtrOutputW return pulumi.ToOutputWithContext(ctx, i).(ModuleBitbucketDatacenterPtrOutput) } +func (i *moduleBitbucketDatacenterPtrType) ToOutput(ctx context.Context) pulumix.Output[*ModuleBitbucketDatacenter] { + return pulumix.Output[*ModuleBitbucketDatacenter]{ + OutputState: i.ToModuleBitbucketDatacenterPtrOutputWithContext(ctx).OutputState, + } +} + type ModuleBitbucketDatacenterOutput struct{ *pulumi.OutputState } func (ModuleBitbucketDatacenterOutput) ElementType() reflect.Type { @@ -382,6 +576,12 @@ func (o ModuleBitbucketDatacenterOutput) ToModuleBitbucketDatacenterPtrOutputWit }).(ModuleBitbucketDatacenterPtrOutput) } +func (o ModuleBitbucketDatacenterOutput) ToOutput(ctx context.Context) pulumix.Output[ModuleBitbucketDatacenter] { + return pulumix.Output[ModuleBitbucketDatacenter]{ + OutputState: o.OutputState, + } +} + // The Bitbucket project containing the repository func (o ModuleBitbucketDatacenterOutput) Namespace() pulumi.StringOutput { return o.ApplyT(func(v ModuleBitbucketDatacenter) string { return v.Namespace }).(pulumi.StringOutput) @@ -401,6 +601,12 @@ func (o ModuleBitbucketDatacenterPtrOutput) ToModuleBitbucketDatacenterPtrOutput return o } +func (o ModuleBitbucketDatacenterPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ModuleBitbucketDatacenter] { + return pulumix.Output[*ModuleBitbucketDatacenter]{ + OutputState: o.OutputState, + } +} + func (o ModuleBitbucketDatacenterPtrOutput) Elem() ModuleBitbucketDatacenterOutput { return o.ApplyT(func(v *ModuleBitbucketDatacenter) ModuleBitbucketDatacenter { if v != nil { @@ -454,6 +660,12 @@ func (i ModuleGithubEnterpriseArgs) ToModuleGithubEnterpriseOutputWithContext(ct return pulumi.ToOutputWithContext(ctx, i).(ModuleGithubEnterpriseOutput) } +func (i ModuleGithubEnterpriseArgs) ToOutput(ctx context.Context) pulumix.Output[ModuleGithubEnterprise] { + return pulumix.Output[ModuleGithubEnterprise]{ + OutputState: i.ToModuleGithubEnterpriseOutputWithContext(ctx).OutputState, + } +} + func (i ModuleGithubEnterpriseArgs) ToModuleGithubEnterprisePtrOutput() ModuleGithubEnterprisePtrOutput { return i.ToModuleGithubEnterprisePtrOutputWithContext(context.Background()) } @@ -495,6 +707,12 @@ func (i *moduleGithubEnterprisePtrType) ToModuleGithubEnterprisePtrOutputWithCon return pulumi.ToOutputWithContext(ctx, i).(ModuleGithubEnterprisePtrOutput) } +func (i *moduleGithubEnterprisePtrType) ToOutput(ctx context.Context) pulumix.Output[*ModuleGithubEnterprise] { + return pulumix.Output[*ModuleGithubEnterprise]{ + OutputState: i.ToModuleGithubEnterprisePtrOutputWithContext(ctx).OutputState, + } +} + type ModuleGithubEnterpriseOutput struct{ *pulumi.OutputState } func (ModuleGithubEnterpriseOutput) ElementType() reflect.Type { @@ -519,6 +737,12 @@ func (o ModuleGithubEnterpriseOutput) ToModuleGithubEnterprisePtrOutputWithConte }).(ModuleGithubEnterprisePtrOutput) } +func (o ModuleGithubEnterpriseOutput) ToOutput(ctx context.Context) pulumix.Output[ModuleGithubEnterprise] { + return pulumix.Output[ModuleGithubEnterprise]{ + OutputState: o.OutputState, + } +} + // The GitHub organization / user the repository belongs to func (o ModuleGithubEnterpriseOutput) Namespace() pulumi.StringOutput { return o.ApplyT(func(v ModuleGithubEnterprise) string { return v.Namespace }).(pulumi.StringOutput) @@ -538,6 +762,12 @@ func (o ModuleGithubEnterprisePtrOutput) ToModuleGithubEnterprisePtrOutputWithCo return o } +func (o ModuleGithubEnterprisePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ModuleGithubEnterprise] { + return pulumix.Output[*ModuleGithubEnterprise]{ + OutputState: o.OutputState, + } +} + func (o ModuleGithubEnterprisePtrOutput) Elem() ModuleGithubEnterpriseOutput { return o.ApplyT(func(v *ModuleGithubEnterprise) ModuleGithubEnterprise { if v != nil { @@ -591,6 +821,12 @@ func (i ModuleGitlabArgs) ToModuleGitlabOutputWithContext(ctx context.Context) M return pulumi.ToOutputWithContext(ctx, i).(ModuleGitlabOutput) } +func (i ModuleGitlabArgs) ToOutput(ctx context.Context) pulumix.Output[ModuleGitlab] { + return pulumix.Output[ModuleGitlab]{ + OutputState: i.ToModuleGitlabOutputWithContext(ctx).OutputState, + } +} + func (i ModuleGitlabArgs) ToModuleGitlabPtrOutput() ModuleGitlabPtrOutput { return i.ToModuleGitlabPtrOutputWithContext(context.Background()) } @@ -632,6 +868,12 @@ func (i *moduleGitlabPtrType) ToModuleGitlabPtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(ModuleGitlabPtrOutput) } +func (i *moduleGitlabPtrType) ToOutput(ctx context.Context) pulumix.Output[*ModuleGitlab] { + return pulumix.Output[*ModuleGitlab]{ + OutputState: i.ToModuleGitlabPtrOutputWithContext(ctx).OutputState, + } +} + type ModuleGitlabOutput struct{ *pulumi.OutputState } func (ModuleGitlabOutput) ElementType() reflect.Type { @@ -656,6 +898,12 @@ func (o ModuleGitlabOutput) ToModuleGitlabPtrOutputWithContext(ctx context.Conte }).(ModuleGitlabPtrOutput) } +func (o ModuleGitlabOutput) ToOutput(ctx context.Context) pulumix.Output[ModuleGitlab] { + return pulumix.Output[ModuleGitlab]{ + OutputState: o.OutputState, + } +} + // The GitLab namespace containing the repository func (o ModuleGitlabOutput) Namespace() pulumi.StringOutput { return o.ApplyT(func(v ModuleGitlab) string { return v.Namespace }).(pulumi.StringOutput) @@ -675,6 +923,12 @@ func (o ModuleGitlabPtrOutput) ToModuleGitlabPtrOutputWithContext(ctx context.Co return o } +func (o ModuleGitlabPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*ModuleGitlab] { + return pulumix.Output[*ModuleGitlab]{ + OutputState: o.OutputState, + } +} + func (o ModuleGitlabPtrOutput) Elem() ModuleGitlabOutput { return o.ApplyT(func(v *ModuleGitlab) ModuleGitlab { if v != nil { @@ -728,6 +982,12 @@ func (i StackAnsibleArgs) ToStackAnsibleOutputWithContext(ctx context.Context) S return pulumi.ToOutputWithContext(ctx, i).(StackAnsibleOutput) } +func (i StackAnsibleArgs) ToOutput(ctx context.Context) pulumix.Output[StackAnsible] { + return pulumix.Output[StackAnsible]{ + OutputState: i.ToStackAnsibleOutputWithContext(ctx).OutputState, + } +} + func (i StackAnsibleArgs) ToStackAnsiblePtrOutput() StackAnsiblePtrOutput { return i.ToStackAnsiblePtrOutputWithContext(context.Background()) } @@ -769,6 +1029,12 @@ func (i *stackAnsiblePtrType) ToStackAnsiblePtrOutputWithContext(ctx context.Con return pulumi.ToOutputWithContext(ctx, i).(StackAnsiblePtrOutput) } +func (i *stackAnsiblePtrType) ToOutput(ctx context.Context) pulumix.Output[*StackAnsible] { + return pulumix.Output[*StackAnsible]{ + OutputState: i.ToStackAnsiblePtrOutputWithContext(ctx).OutputState, + } +} + type StackAnsibleOutput struct{ *pulumi.OutputState } func (StackAnsibleOutput) ElementType() reflect.Type { @@ -793,6 +1059,12 @@ func (o StackAnsibleOutput) ToStackAnsiblePtrOutputWithContext(ctx context.Conte }).(StackAnsiblePtrOutput) } +func (o StackAnsibleOutput) ToOutput(ctx context.Context) pulumix.Output[StackAnsible] { + return pulumix.Output[StackAnsible]{ + OutputState: o.OutputState, + } +} + // The playbook Ansible should run. func (o StackAnsibleOutput) Playbook() pulumi.StringOutput { return o.ApplyT(func(v StackAnsible) string { return v.Playbook }).(pulumi.StringOutput) @@ -812,6 +1084,12 @@ func (o StackAnsiblePtrOutput) ToStackAnsiblePtrOutputWithContext(ctx context.Co return o } +func (o StackAnsiblePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackAnsible] { + return pulumix.Output[*StackAnsible]{ + OutputState: o.OutputState, + } +} + func (o StackAnsiblePtrOutput) Elem() StackAnsibleOutput { return o.ApplyT(func(v *StackAnsible) StackAnsible { if v != nil { @@ -865,6 +1143,12 @@ func (i StackAzureDevopsArgs) ToStackAzureDevopsOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(StackAzureDevopsOutput) } +func (i StackAzureDevopsArgs) ToOutput(ctx context.Context) pulumix.Output[StackAzureDevops] { + return pulumix.Output[StackAzureDevops]{ + OutputState: i.ToStackAzureDevopsOutputWithContext(ctx).OutputState, + } +} + func (i StackAzureDevopsArgs) ToStackAzureDevopsPtrOutput() StackAzureDevopsPtrOutput { return i.ToStackAzureDevopsPtrOutputWithContext(context.Background()) } @@ -906,6 +1190,12 @@ func (i *stackAzureDevopsPtrType) ToStackAzureDevopsPtrOutputWithContext(ctx con return pulumi.ToOutputWithContext(ctx, i).(StackAzureDevopsPtrOutput) } +func (i *stackAzureDevopsPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackAzureDevops] { + return pulumix.Output[*StackAzureDevops]{ + OutputState: i.ToStackAzureDevopsPtrOutputWithContext(ctx).OutputState, + } +} + type StackAzureDevopsOutput struct{ *pulumi.OutputState } func (StackAzureDevopsOutput) ElementType() reflect.Type { @@ -930,6 +1220,12 @@ func (o StackAzureDevopsOutput) ToStackAzureDevopsPtrOutputWithContext(ctx conte }).(StackAzureDevopsPtrOutput) } +func (o StackAzureDevopsOutput) ToOutput(ctx context.Context) pulumix.Output[StackAzureDevops] { + return pulumix.Output[StackAzureDevops]{ + OutputState: o.OutputState, + } +} + // The name of the Azure DevOps project func (o StackAzureDevopsOutput) Project() pulumi.StringOutput { return o.ApplyT(func(v StackAzureDevops) string { return v.Project }).(pulumi.StringOutput) @@ -949,6 +1245,12 @@ func (o StackAzureDevopsPtrOutput) ToStackAzureDevopsPtrOutputWithContext(ctx co return o } +func (o StackAzureDevopsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackAzureDevops] { + return pulumix.Output[*StackAzureDevops]{ + OutputState: o.OutputState, + } +} + func (o StackAzureDevopsPtrOutput) Elem() StackAzureDevopsOutput { return o.ApplyT(func(v *StackAzureDevops) StackAzureDevops { if v != nil { @@ -1002,6 +1304,12 @@ func (i StackBitbucketCloudArgs) ToStackBitbucketCloudOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StackBitbucketCloudOutput) } +func (i StackBitbucketCloudArgs) ToOutput(ctx context.Context) pulumix.Output[StackBitbucketCloud] { + return pulumix.Output[StackBitbucketCloud]{ + OutputState: i.ToStackBitbucketCloudOutputWithContext(ctx).OutputState, + } +} + func (i StackBitbucketCloudArgs) ToStackBitbucketCloudPtrOutput() StackBitbucketCloudPtrOutput { return i.ToStackBitbucketCloudPtrOutputWithContext(context.Background()) } @@ -1043,6 +1351,12 @@ func (i *stackBitbucketCloudPtrType) ToStackBitbucketCloudPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(StackBitbucketCloudPtrOutput) } +func (i *stackBitbucketCloudPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackBitbucketCloud] { + return pulumix.Output[*StackBitbucketCloud]{ + OutputState: i.ToStackBitbucketCloudPtrOutputWithContext(ctx).OutputState, + } +} + type StackBitbucketCloudOutput struct{ *pulumi.OutputState } func (StackBitbucketCloudOutput) ElementType() reflect.Type { @@ -1067,6 +1381,12 @@ func (o StackBitbucketCloudOutput) ToStackBitbucketCloudPtrOutputWithContext(ctx }).(StackBitbucketCloudPtrOutput) } +func (o StackBitbucketCloudOutput) ToOutput(ctx context.Context) pulumix.Output[StackBitbucketCloud] { + return pulumix.Output[StackBitbucketCloud]{ + OutputState: o.OutputState, + } +} + // The Bitbucket project containing the repository func (o StackBitbucketCloudOutput) Namespace() pulumi.StringOutput { return o.ApplyT(func(v StackBitbucketCloud) string { return v.Namespace }).(pulumi.StringOutput) @@ -1086,6 +1406,12 @@ func (o StackBitbucketCloudPtrOutput) ToStackBitbucketCloudPtrOutputWithContext( return o } +func (o StackBitbucketCloudPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackBitbucketCloud] { + return pulumix.Output[*StackBitbucketCloud]{ + OutputState: o.OutputState, + } +} + func (o StackBitbucketCloudPtrOutput) Elem() StackBitbucketCloudOutput { return o.ApplyT(func(v *StackBitbucketCloud) StackBitbucketCloud { if v != nil { @@ -1139,6 +1465,12 @@ func (i StackBitbucketDatacenterArgs) ToStackBitbucketDatacenterOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(StackBitbucketDatacenterOutput) } +func (i StackBitbucketDatacenterArgs) ToOutput(ctx context.Context) pulumix.Output[StackBitbucketDatacenter] { + return pulumix.Output[StackBitbucketDatacenter]{ + OutputState: i.ToStackBitbucketDatacenterOutputWithContext(ctx).OutputState, + } +} + func (i StackBitbucketDatacenterArgs) ToStackBitbucketDatacenterPtrOutput() StackBitbucketDatacenterPtrOutput { return i.ToStackBitbucketDatacenterPtrOutputWithContext(context.Background()) } @@ -1180,6 +1512,12 @@ func (i *stackBitbucketDatacenterPtrType) ToStackBitbucketDatacenterPtrOutputWit return pulumi.ToOutputWithContext(ctx, i).(StackBitbucketDatacenterPtrOutput) } +func (i *stackBitbucketDatacenterPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackBitbucketDatacenter] { + return pulumix.Output[*StackBitbucketDatacenter]{ + OutputState: i.ToStackBitbucketDatacenterPtrOutputWithContext(ctx).OutputState, + } +} + type StackBitbucketDatacenterOutput struct{ *pulumi.OutputState } func (StackBitbucketDatacenterOutput) ElementType() reflect.Type { @@ -1204,6 +1542,12 @@ func (o StackBitbucketDatacenterOutput) ToStackBitbucketDatacenterPtrOutputWithC }).(StackBitbucketDatacenterPtrOutput) } +func (o StackBitbucketDatacenterOutput) ToOutput(ctx context.Context) pulumix.Output[StackBitbucketDatacenter] { + return pulumix.Output[StackBitbucketDatacenter]{ + OutputState: o.OutputState, + } +} + // The Bitbucket project containing the repository func (o StackBitbucketDatacenterOutput) Namespace() pulumi.StringOutput { return o.ApplyT(func(v StackBitbucketDatacenter) string { return v.Namespace }).(pulumi.StringOutput) @@ -1223,6 +1567,12 @@ func (o StackBitbucketDatacenterPtrOutput) ToStackBitbucketDatacenterPtrOutputWi return o } +func (o StackBitbucketDatacenterPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackBitbucketDatacenter] { + return pulumix.Output[*StackBitbucketDatacenter]{ + OutputState: o.OutputState, + } +} + func (o StackBitbucketDatacenterPtrOutput) Elem() StackBitbucketDatacenterOutput { return o.ApplyT(func(v *StackBitbucketDatacenter) StackBitbucketDatacenter { if v != nil { @@ -1288,6 +1638,12 @@ func (i StackCloudformationArgs) ToStackCloudformationOutputWithContext(ctx cont return pulumi.ToOutputWithContext(ctx, i).(StackCloudformationOutput) } +func (i StackCloudformationArgs) ToOutput(ctx context.Context) pulumix.Output[StackCloudformation] { + return pulumix.Output[StackCloudformation]{ + OutputState: i.ToStackCloudformationOutputWithContext(ctx).OutputState, + } +} + func (i StackCloudformationArgs) ToStackCloudformationPtrOutput() StackCloudformationPtrOutput { return i.ToStackCloudformationPtrOutputWithContext(context.Background()) } @@ -1329,6 +1685,12 @@ func (i *stackCloudformationPtrType) ToStackCloudformationPtrOutputWithContext(c return pulumi.ToOutputWithContext(ctx, i).(StackCloudformationPtrOutput) } +func (i *stackCloudformationPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackCloudformation] { + return pulumix.Output[*StackCloudformation]{ + OutputState: i.ToStackCloudformationPtrOutputWithContext(ctx).OutputState, + } +} + type StackCloudformationOutput struct{ *pulumi.OutputState } func (StackCloudformationOutput) ElementType() reflect.Type { @@ -1353,6 +1715,12 @@ func (o StackCloudformationOutput) ToStackCloudformationPtrOutputWithContext(ctx }).(StackCloudformationPtrOutput) } +func (o StackCloudformationOutput) ToOutput(ctx context.Context) pulumix.Output[StackCloudformation] { + return pulumix.Output[StackCloudformation]{ + OutputState: o.OutputState, + } +} + // Template file `cloudformation package` will be called on func (o StackCloudformationOutput) EntryTemplateFile() pulumi.StringOutput { return o.ApplyT(func(v StackCloudformation) string { return v.EntryTemplateFile }).(pulumi.StringOutput) @@ -1387,6 +1755,12 @@ func (o StackCloudformationPtrOutput) ToStackCloudformationPtrOutputWithContext( return o } +func (o StackCloudformationPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackCloudformation] { + return pulumix.Output[*StackCloudformation]{ + OutputState: o.OutputState, + } +} + func (o StackCloudformationPtrOutput) Elem() StackCloudformationOutput { return o.ApplyT(func(v *StackCloudformation) StackCloudformation { if v != nil { @@ -1470,6 +1844,12 @@ func (i StackGithubEnterpriseArgs) ToStackGithubEnterpriseOutputWithContext(ctx return pulumi.ToOutputWithContext(ctx, i).(StackGithubEnterpriseOutput) } +func (i StackGithubEnterpriseArgs) ToOutput(ctx context.Context) pulumix.Output[StackGithubEnterprise] { + return pulumix.Output[StackGithubEnterprise]{ + OutputState: i.ToStackGithubEnterpriseOutputWithContext(ctx).OutputState, + } +} + func (i StackGithubEnterpriseArgs) ToStackGithubEnterprisePtrOutput() StackGithubEnterprisePtrOutput { return i.ToStackGithubEnterprisePtrOutputWithContext(context.Background()) } @@ -1511,6 +1891,12 @@ func (i *stackGithubEnterprisePtrType) ToStackGithubEnterprisePtrOutputWithConte return pulumi.ToOutputWithContext(ctx, i).(StackGithubEnterprisePtrOutput) } +func (i *stackGithubEnterprisePtrType) ToOutput(ctx context.Context) pulumix.Output[*StackGithubEnterprise] { + return pulumix.Output[*StackGithubEnterprise]{ + OutputState: i.ToStackGithubEnterprisePtrOutputWithContext(ctx).OutputState, + } +} + type StackGithubEnterpriseOutput struct{ *pulumi.OutputState } func (StackGithubEnterpriseOutput) ElementType() reflect.Type { @@ -1535,6 +1921,12 @@ func (o StackGithubEnterpriseOutput) ToStackGithubEnterprisePtrOutputWithContext }).(StackGithubEnterprisePtrOutput) } +func (o StackGithubEnterpriseOutput) ToOutput(ctx context.Context) pulumix.Output[StackGithubEnterprise] { + return pulumix.Output[StackGithubEnterprise]{ + OutputState: o.OutputState, + } +} + // The GitHub organization / user the repository belongs to func (o StackGithubEnterpriseOutput) Namespace() pulumi.StringOutput { return o.ApplyT(func(v StackGithubEnterprise) string { return v.Namespace }).(pulumi.StringOutput) @@ -1554,6 +1946,12 @@ func (o StackGithubEnterprisePtrOutput) ToStackGithubEnterprisePtrOutputWithCont return o } +func (o StackGithubEnterprisePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackGithubEnterprise] { + return pulumix.Output[*StackGithubEnterprise]{ + OutputState: o.OutputState, + } +} + func (o StackGithubEnterprisePtrOutput) Elem() StackGithubEnterpriseOutput { return o.ApplyT(func(v *StackGithubEnterprise) StackGithubEnterprise { if v != nil { @@ -1607,6 +2005,12 @@ func (i StackGitlabArgs) ToStackGitlabOutputWithContext(ctx context.Context) Sta return pulumi.ToOutputWithContext(ctx, i).(StackGitlabOutput) } +func (i StackGitlabArgs) ToOutput(ctx context.Context) pulumix.Output[StackGitlab] { + return pulumix.Output[StackGitlab]{ + OutputState: i.ToStackGitlabOutputWithContext(ctx).OutputState, + } +} + func (i StackGitlabArgs) ToStackGitlabPtrOutput() StackGitlabPtrOutput { return i.ToStackGitlabPtrOutputWithContext(context.Background()) } @@ -1648,6 +2052,12 @@ func (i *stackGitlabPtrType) ToStackGitlabPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(StackGitlabPtrOutput) } +func (i *stackGitlabPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackGitlab] { + return pulumix.Output[*StackGitlab]{ + OutputState: i.ToStackGitlabPtrOutputWithContext(ctx).OutputState, + } +} + type StackGitlabOutput struct{ *pulumi.OutputState } func (StackGitlabOutput) ElementType() reflect.Type { @@ -1672,6 +2082,12 @@ func (o StackGitlabOutput) ToStackGitlabPtrOutputWithContext(ctx context.Context }).(StackGitlabPtrOutput) } +func (o StackGitlabOutput) ToOutput(ctx context.Context) pulumix.Output[StackGitlab] { + return pulumix.Output[StackGitlab]{ + OutputState: o.OutputState, + } +} + // The GitLab namespace containing the repository func (o StackGitlabOutput) Namespace() pulumi.StringOutput { return o.ApplyT(func(v StackGitlab) string { return v.Namespace }).(pulumi.StringOutput) @@ -1691,6 +2107,12 @@ func (o StackGitlabPtrOutput) ToStackGitlabPtrOutputWithContext(ctx context.Cont return o } +func (o StackGitlabPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackGitlab] { + return pulumix.Output[*StackGitlab]{ + OutputState: o.OutputState, + } +} + func (o StackGitlabPtrOutput) Elem() StackGitlabOutput { return o.ApplyT(func(v *StackGitlab) StackGitlab { if v != nil { @@ -1712,6 +2134,8 @@ func (o StackGitlabPtrOutput) Namespace() pulumi.StringPtrOutput { } type StackKubernetes struct { + // Kubectl version. + KubectlVersion *string `pulumi:"kubectlVersion"` // Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. Namespace *string `pulumi:"namespace"` } @@ -1728,6 +2152,8 @@ type StackKubernetesInput interface { } type StackKubernetesArgs struct { + // Kubectl version. + KubectlVersion pulumi.StringPtrInput `pulumi:"kubectlVersion"` // Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. Namespace pulumi.StringPtrInput `pulumi:"namespace"` } @@ -1744,6 +2170,12 @@ func (i StackKubernetesArgs) ToStackKubernetesOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StackKubernetesOutput) } +func (i StackKubernetesArgs) ToOutput(ctx context.Context) pulumix.Output[StackKubernetes] { + return pulumix.Output[StackKubernetes]{ + OutputState: i.ToStackKubernetesOutputWithContext(ctx).OutputState, + } +} + func (i StackKubernetesArgs) ToStackKubernetesPtrOutput() StackKubernetesPtrOutput { return i.ToStackKubernetesPtrOutputWithContext(context.Background()) } @@ -1785,6 +2217,12 @@ func (i *stackKubernetesPtrType) ToStackKubernetesPtrOutputWithContext(ctx conte return pulumi.ToOutputWithContext(ctx, i).(StackKubernetesPtrOutput) } +func (i *stackKubernetesPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackKubernetes] { + return pulumix.Output[*StackKubernetes]{ + OutputState: i.ToStackKubernetesPtrOutputWithContext(ctx).OutputState, + } +} + type StackKubernetesOutput struct{ *pulumi.OutputState } func (StackKubernetesOutput) ElementType() reflect.Type { @@ -1809,6 +2247,17 @@ func (o StackKubernetesOutput) ToStackKubernetesPtrOutputWithContext(ctx context }).(StackKubernetesPtrOutput) } +func (o StackKubernetesOutput) ToOutput(ctx context.Context) pulumix.Output[StackKubernetes] { + return pulumix.Output[StackKubernetes]{ + OutputState: o.OutputState, + } +} + +// Kubectl version. +func (o StackKubernetesOutput) KubectlVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v StackKubernetes) *string { return v.KubectlVersion }).(pulumi.StringPtrOutput) +} + // Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. func (o StackKubernetesOutput) Namespace() pulumi.StringPtrOutput { return o.ApplyT(func(v StackKubernetes) *string { return v.Namespace }).(pulumi.StringPtrOutput) @@ -1828,6 +2277,12 @@ func (o StackKubernetesPtrOutput) ToStackKubernetesPtrOutputWithContext(ctx cont return o } +func (o StackKubernetesPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackKubernetes] { + return pulumix.Output[*StackKubernetes]{ + OutputState: o.OutputState, + } +} + func (o StackKubernetesPtrOutput) Elem() StackKubernetesOutput { return o.ApplyT(func(v *StackKubernetes) StackKubernetes { if v != nil { @@ -1838,6 +2293,16 @@ func (o StackKubernetesPtrOutput) Elem() StackKubernetesOutput { }).(StackKubernetesOutput) } +// Kubectl version. +func (o StackKubernetesPtrOutput) KubectlVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *StackKubernetes) *string { + if v == nil { + return nil + } + return v.KubectlVersion + }).(pulumi.StringPtrOutput) +} + // Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. func (o StackKubernetesPtrOutput) Namespace() pulumi.StringPtrOutput { return o.ApplyT(func(v *StackKubernetes) *string { @@ -1885,6 +2350,12 @@ func (i StackPulumiArgs) ToStackPulumiOutputWithContext(ctx context.Context) Sta return pulumi.ToOutputWithContext(ctx, i).(StackPulumiOutput) } +func (i StackPulumiArgs) ToOutput(ctx context.Context) pulumix.Output[StackPulumi] { + return pulumix.Output[StackPulumi]{ + OutputState: i.ToStackPulumiOutputWithContext(ctx).OutputState, + } +} + func (i StackPulumiArgs) ToStackPulumiPtrOutput() StackPulumiPtrOutput { return i.ToStackPulumiPtrOutputWithContext(context.Background()) } @@ -1926,6 +2397,12 @@ func (i *stackPulumiPtrType) ToStackPulumiPtrOutputWithContext(ctx context.Conte return pulumi.ToOutputWithContext(ctx, i).(StackPulumiPtrOutput) } +func (i *stackPulumiPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackPulumi] { + return pulumix.Output[*StackPulumi]{ + OutputState: i.ToStackPulumiPtrOutputWithContext(ctx).OutputState, + } +} + type StackPulumiOutput struct{ *pulumi.OutputState } func (StackPulumiOutput) ElementType() reflect.Type { @@ -1950,6 +2427,12 @@ func (o StackPulumiOutput) ToStackPulumiPtrOutputWithContext(ctx context.Context }).(StackPulumiPtrOutput) } +func (o StackPulumiOutput) ToOutput(ctx context.Context) pulumix.Output[StackPulumi] { + return pulumix.Output[StackPulumi]{ + OutputState: o.OutputState, + } +} + // State backend to log into on Run initialize. func (o StackPulumiOutput) LoginUrl() pulumi.StringOutput { return o.ApplyT(func(v StackPulumi) string { return v.LoginUrl }).(pulumi.StringOutput) @@ -1974,6 +2457,12 @@ func (o StackPulumiPtrOutput) ToStackPulumiPtrOutputWithContext(ctx context.Cont return o } +func (o StackPulumiPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackPulumi] { + return pulumix.Output[*StackPulumi]{ + OutputState: o.OutputState, + } +} + func (o StackPulumiPtrOutput) Elem() StackPulumiOutput { return o.ApplyT(func(v *StackPulumi) StackPulumi { if v != nil { @@ -2004,132 +2493,169 @@ func (o StackPulumiPtrOutput) StackName() pulumi.StringPtrOutput { }).(pulumi.StringPtrOutput) } -type StackShowcase struct { +type StackRawGit struct { + // User-friendly namespace for the repository, this is for cosmetic purposes only Namespace string `pulumi:"namespace"` + // HTTPS URL of the Git repository + Url string `pulumi:"url"` } -// StackShowcaseInput is an input type that accepts StackShowcaseArgs and StackShowcaseOutput values. -// You can construct a concrete instance of `StackShowcaseInput` via: +// StackRawGitInput is an input type that accepts StackRawGitArgs and StackRawGitOutput values. +// You can construct a concrete instance of `StackRawGitInput` via: // -// StackShowcaseArgs{...} -type StackShowcaseInput interface { +// StackRawGitArgs{...} +type StackRawGitInput interface { pulumi.Input - ToStackShowcaseOutput() StackShowcaseOutput - ToStackShowcaseOutputWithContext(context.Context) StackShowcaseOutput + ToStackRawGitOutput() StackRawGitOutput + ToStackRawGitOutputWithContext(context.Context) StackRawGitOutput } -type StackShowcaseArgs struct { +type StackRawGitArgs struct { + // User-friendly namespace for the repository, this is for cosmetic purposes only Namespace pulumi.StringInput `pulumi:"namespace"` + // HTTPS URL of the Git repository + Url pulumi.StringInput `pulumi:"url"` } -func (StackShowcaseArgs) ElementType() reflect.Type { - return reflect.TypeOf((*StackShowcase)(nil)).Elem() +func (StackRawGitArgs) ElementType() reflect.Type { + return reflect.TypeOf((*StackRawGit)(nil)).Elem() } -func (i StackShowcaseArgs) ToStackShowcaseOutput() StackShowcaseOutput { - return i.ToStackShowcaseOutputWithContext(context.Background()) +func (i StackRawGitArgs) ToStackRawGitOutput() StackRawGitOutput { + return i.ToStackRawGitOutputWithContext(context.Background()) } -func (i StackShowcaseArgs) ToStackShowcaseOutputWithContext(ctx context.Context) StackShowcaseOutput { - return pulumi.ToOutputWithContext(ctx, i).(StackShowcaseOutput) +func (i StackRawGitArgs) ToStackRawGitOutputWithContext(ctx context.Context) StackRawGitOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackRawGitOutput) } -func (i StackShowcaseArgs) ToStackShowcasePtrOutput() StackShowcasePtrOutput { - return i.ToStackShowcasePtrOutputWithContext(context.Background()) +func (i StackRawGitArgs) ToOutput(ctx context.Context) pulumix.Output[StackRawGit] { + return pulumix.Output[StackRawGit]{ + OutputState: i.ToStackRawGitOutputWithContext(ctx).OutputState, + } } -func (i StackShowcaseArgs) ToStackShowcasePtrOutputWithContext(ctx context.Context) StackShowcasePtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(StackShowcaseOutput).ToStackShowcasePtrOutputWithContext(ctx) +func (i StackRawGitArgs) ToStackRawGitPtrOutput() StackRawGitPtrOutput { + return i.ToStackRawGitPtrOutputWithContext(context.Background()) } -// StackShowcasePtrInput is an input type that accepts StackShowcaseArgs, StackShowcasePtr and StackShowcasePtrOutput values. -// You can construct a concrete instance of `StackShowcasePtrInput` via: +func (i StackRawGitArgs) ToStackRawGitPtrOutputWithContext(ctx context.Context) StackRawGitPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackRawGitOutput).ToStackRawGitPtrOutputWithContext(ctx) +} + +// StackRawGitPtrInput is an input type that accepts StackRawGitArgs, StackRawGitPtr and StackRawGitPtrOutput values. +// You can construct a concrete instance of `StackRawGitPtrInput` via: // -// StackShowcaseArgs{...} +// StackRawGitArgs{...} // // or: // // nil -type StackShowcasePtrInput interface { +type StackRawGitPtrInput interface { pulumi.Input - ToStackShowcasePtrOutput() StackShowcasePtrOutput - ToStackShowcasePtrOutputWithContext(context.Context) StackShowcasePtrOutput + ToStackRawGitPtrOutput() StackRawGitPtrOutput + ToStackRawGitPtrOutputWithContext(context.Context) StackRawGitPtrOutput } -type stackShowcasePtrType StackShowcaseArgs +type stackRawGitPtrType StackRawGitArgs -func StackShowcasePtr(v *StackShowcaseArgs) StackShowcasePtrInput { - return (*stackShowcasePtrType)(v) +func StackRawGitPtr(v *StackRawGitArgs) StackRawGitPtrInput { + return (*stackRawGitPtrType)(v) } -func (*stackShowcasePtrType) ElementType() reflect.Type { - return reflect.TypeOf((**StackShowcase)(nil)).Elem() +func (*stackRawGitPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**StackRawGit)(nil)).Elem() } -func (i *stackShowcasePtrType) ToStackShowcasePtrOutput() StackShowcasePtrOutput { - return i.ToStackShowcasePtrOutputWithContext(context.Background()) +func (i *stackRawGitPtrType) ToStackRawGitPtrOutput() StackRawGitPtrOutput { + return i.ToStackRawGitPtrOutputWithContext(context.Background()) } -func (i *stackShowcasePtrType) ToStackShowcasePtrOutputWithContext(ctx context.Context) StackShowcasePtrOutput { - return pulumi.ToOutputWithContext(ctx, i).(StackShowcasePtrOutput) +func (i *stackRawGitPtrType) ToStackRawGitPtrOutputWithContext(ctx context.Context) StackRawGitPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackRawGitPtrOutput) } -type StackShowcaseOutput struct{ *pulumi.OutputState } +func (i *stackRawGitPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackRawGit] { + return pulumix.Output[*StackRawGit]{ + OutputState: i.ToStackRawGitPtrOutputWithContext(ctx).OutputState, + } +} -func (StackShowcaseOutput) ElementType() reflect.Type { - return reflect.TypeOf((*StackShowcase)(nil)).Elem() +type StackRawGitOutput struct{ *pulumi.OutputState } + +func (StackRawGitOutput) ElementType() reflect.Type { + return reflect.TypeOf((*StackRawGit)(nil)).Elem() } -func (o StackShowcaseOutput) ToStackShowcaseOutput() StackShowcaseOutput { +func (o StackRawGitOutput) ToStackRawGitOutput() StackRawGitOutput { return o } -func (o StackShowcaseOutput) ToStackShowcaseOutputWithContext(ctx context.Context) StackShowcaseOutput { +func (o StackRawGitOutput) ToStackRawGitOutputWithContext(ctx context.Context) StackRawGitOutput { return o } -func (o StackShowcaseOutput) ToStackShowcasePtrOutput() StackShowcasePtrOutput { - return o.ToStackShowcasePtrOutputWithContext(context.Background()) +func (o StackRawGitOutput) ToStackRawGitPtrOutput() StackRawGitPtrOutput { + return o.ToStackRawGitPtrOutputWithContext(context.Background()) } -func (o StackShowcaseOutput) ToStackShowcasePtrOutputWithContext(ctx context.Context) StackShowcasePtrOutput { - return o.ApplyTWithContext(ctx, func(_ context.Context, v StackShowcase) *StackShowcase { +func (o StackRawGitOutput) ToStackRawGitPtrOutputWithContext(ctx context.Context) StackRawGitPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v StackRawGit) *StackRawGit { return &v - }).(StackShowcasePtrOutput) + }).(StackRawGitPtrOutput) } -func (o StackShowcaseOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v StackShowcase) string { return v.Namespace }).(pulumi.StringOutput) +func (o StackRawGitOutput) ToOutput(ctx context.Context) pulumix.Output[StackRawGit] { + return pulumix.Output[StackRawGit]{ + OutputState: o.OutputState, + } } -type StackShowcasePtrOutput struct{ *pulumi.OutputState } +// User-friendly namespace for the repository, this is for cosmetic purposes only +func (o StackRawGitOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v StackRawGit) string { return v.Namespace }).(pulumi.StringOutput) +} -func (StackShowcasePtrOutput) ElementType() reflect.Type { - return reflect.TypeOf((**StackShowcase)(nil)).Elem() +// HTTPS URL of the Git repository +func (o StackRawGitOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v StackRawGit) string { return v.Url }).(pulumi.StringOutput) } -func (o StackShowcasePtrOutput) ToStackShowcasePtrOutput() StackShowcasePtrOutput { +type StackRawGitPtrOutput struct{ *pulumi.OutputState } + +func (StackRawGitPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**StackRawGit)(nil)).Elem() +} + +func (o StackRawGitPtrOutput) ToStackRawGitPtrOutput() StackRawGitPtrOutput { return o } -func (o StackShowcasePtrOutput) ToStackShowcasePtrOutputWithContext(ctx context.Context) StackShowcasePtrOutput { +func (o StackRawGitPtrOutput) ToStackRawGitPtrOutputWithContext(ctx context.Context) StackRawGitPtrOutput { return o } -func (o StackShowcasePtrOutput) Elem() StackShowcaseOutput { - return o.ApplyT(func(v *StackShowcase) StackShowcase { +func (o StackRawGitPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackRawGit] { + return pulumix.Output[*StackRawGit]{ + OutputState: o.OutputState, + } +} + +func (o StackRawGitPtrOutput) Elem() StackRawGitOutput { + return o.ApplyT(func(v *StackRawGit) StackRawGit { if v != nil { return *v } - var ret StackShowcase + var ret StackRawGit return ret - }).(StackShowcaseOutput) + }).(StackRawGitOutput) } -func (o StackShowcasePtrOutput) Namespace() pulumi.StringPtrOutput { - return o.ApplyT(func(v *StackShowcase) *string { +// User-friendly namespace for the repository, this is for cosmetic purposes only +func (o StackRawGitPtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *StackRawGit) *string { if v == nil { return nil } @@ -2137,1565 +2663,6715 @@ func (o StackShowcasePtrOutput) Namespace() pulumi.StringPtrOutput { }).(pulumi.StringPtrOutput) } -type GetModuleAzureDevop struct { - Project string `pulumi:"project"` +// HTTPS URL of the Git repository +func (o StackRawGitPtrOutput) Url() pulumi.StringPtrOutput { + return o.ApplyT(func(v *StackRawGit) *string { + if v == nil { + return nil + } + return &v.Url + }).(pulumi.StringPtrOutput) } -// GetModuleAzureDevopInput is an input type that accepts GetModuleAzureDevopArgs and GetModuleAzureDevopOutput values. -// You can construct a concrete instance of `GetModuleAzureDevopInput` via: -// +type StackShowcase struct { + Namespace string `pulumi:"namespace"` +} + +// StackShowcaseInput is an input type that accepts StackShowcaseArgs and StackShowcaseOutput values. +// You can construct a concrete instance of `StackShowcaseInput` via: +// +// StackShowcaseArgs{...} +type StackShowcaseInput interface { + pulumi.Input + + ToStackShowcaseOutput() StackShowcaseOutput + ToStackShowcaseOutputWithContext(context.Context) StackShowcaseOutput +} + +type StackShowcaseArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (StackShowcaseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*StackShowcase)(nil)).Elem() +} + +func (i StackShowcaseArgs) ToStackShowcaseOutput() StackShowcaseOutput { + return i.ToStackShowcaseOutputWithContext(context.Background()) +} + +func (i StackShowcaseArgs) ToStackShowcaseOutputWithContext(ctx context.Context) StackShowcaseOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackShowcaseOutput) +} + +func (i StackShowcaseArgs) ToOutput(ctx context.Context) pulumix.Output[StackShowcase] { + return pulumix.Output[StackShowcase]{ + OutputState: i.ToStackShowcaseOutputWithContext(ctx).OutputState, + } +} + +func (i StackShowcaseArgs) ToStackShowcasePtrOutput() StackShowcasePtrOutput { + return i.ToStackShowcasePtrOutputWithContext(context.Background()) +} + +func (i StackShowcaseArgs) ToStackShowcasePtrOutputWithContext(ctx context.Context) StackShowcasePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackShowcaseOutput).ToStackShowcasePtrOutputWithContext(ctx) +} + +// StackShowcasePtrInput is an input type that accepts StackShowcaseArgs, StackShowcasePtr and StackShowcasePtrOutput values. +// You can construct a concrete instance of `StackShowcasePtrInput` via: +// +// StackShowcaseArgs{...} +// +// or: +// +// nil +type StackShowcasePtrInput interface { + pulumi.Input + + ToStackShowcasePtrOutput() StackShowcasePtrOutput + ToStackShowcasePtrOutputWithContext(context.Context) StackShowcasePtrOutput +} + +type stackShowcasePtrType StackShowcaseArgs + +func StackShowcasePtr(v *StackShowcaseArgs) StackShowcasePtrInput { + return (*stackShowcasePtrType)(v) +} + +func (*stackShowcasePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**StackShowcase)(nil)).Elem() +} + +func (i *stackShowcasePtrType) ToStackShowcasePtrOutput() StackShowcasePtrOutput { + return i.ToStackShowcasePtrOutputWithContext(context.Background()) +} + +func (i *stackShowcasePtrType) ToStackShowcasePtrOutputWithContext(ctx context.Context) StackShowcasePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackShowcasePtrOutput) +} + +func (i *stackShowcasePtrType) ToOutput(ctx context.Context) pulumix.Output[*StackShowcase] { + return pulumix.Output[*StackShowcase]{ + OutputState: i.ToStackShowcasePtrOutputWithContext(ctx).OutputState, + } +} + +type StackShowcaseOutput struct{ *pulumi.OutputState } + +func (StackShowcaseOutput) ElementType() reflect.Type { + return reflect.TypeOf((*StackShowcase)(nil)).Elem() +} + +func (o StackShowcaseOutput) ToStackShowcaseOutput() StackShowcaseOutput { + return o +} + +func (o StackShowcaseOutput) ToStackShowcaseOutputWithContext(ctx context.Context) StackShowcaseOutput { + return o +} + +func (o StackShowcaseOutput) ToStackShowcasePtrOutput() StackShowcasePtrOutput { + return o.ToStackShowcasePtrOutputWithContext(context.Background()) +} + +func (o StackShowcaseOutput) ToStackShowcasePtrOutputWithContext(ctx context.Context) StackShowcasePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v StackShowcase) *StackShowcase { + return &v + }).(StackShowcasePtrOutput) +} + +func (o StackShowcaseOutput) ToOutput(ctx context.Context) pulumix.Output[StackShowcase] { + return pulumix.Output[StackShowcase]{ + OutputState: o.OutputState, + } +} + +func (o StackShowcaseOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v StackShowcase) string { return v.Namespace }).(pulumi.StringOutput) +} + +type StackShowcasePtrOutput struct{ *pulumi.OutputState } + +func (StackShowcasePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**StackShowcase)(nil)).Elem() +} + +func (o StackShowcasePtrOutput) ToStackShowcasePtrOutput() StackShowcasePtrOutput { + return o +} + +func (o StackShowcasePtrOutput) ToStackShowcasePtrOutputWithContext(ctx context.Context) StackShowcasePtrOutput { + return o +} + +func (o StackShowcasePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackShowcase] { + return pulumix.Output[*StackShowcase]{ + OutputState: o.OutputState, + } +} + +func (o StackShowcasePtrOutput) Elem() StackShowcaseOutput { + return o.ApplyT(func(v *StackShowcase) StackShowcase { + if v != nil { + return *v + } + var ret StackShowcase + return ret + }).(StackShowcaseOutput) +} + +func (o StackShowcasePtrOutput) Namespace() pulumi.StringPtrOutput { + return o.ApplyT(func(v *StackShowcase) *string { + if v == nil { + return nil + } + return &v.Namespace + }).(pulumi.StringPtrOutput) +} + +type StackTerragrunt struct { + TerraformVersion *string `pulumi:"terraformVersion"` + // Terragrunt version. + TerragruntVersion *string `pulumi:"terragruntVersion"` + // Whether to use `terragrunt run-all` instead of `terragrunt`. + UseRunAll *bool `pulumi:"useRunAll"` + UseSmartSanitization *bool `pulumi:"useSmartSanitization"` +} + +// StackTerragruntInput is an input type that accepts StackTerragruntArgs and StackTerragruntOutput values. +// You can construct a concrete instance of `StackTerragruntInput` via: +// +// StackTerragruntArgs{...} +type StackTerragruntInput interface { + pulumi.Input + + ToStackTerragruntOutput() StackTerragruntOutput + ToStackTerragruntOutputWithContext(context.Context) StackTerragruntOutput +} + +type StackTerragruntArgs struct { + TerraformVersion pulumi.StringPtrInput `pulumi:"terraformVersion"` + // Terragrunt version. + TerragruntVersion pulumi.StringPtrInput `pulumi:"terragruntVersion"` + // Whether to use `terragrunt run-all` instead of `terragrunt`. + UseRunAll pulumi.BoolPtrInput `pulumi:"useRunAll"` + UseSmartSanitization pulumi.BoolPtrInput `pulumi:"useSmartSanitization"` +} + +func (StackTerragruntArgs) ElementType() reflect.Type { + return reflect.TypeOf((*StackTerragrunt)(nil)).Elem() +} + +func (i StackTerragruntArgs) ToStackTerragruntOutput() StackTerragruntOutput { + return i.ToStackTerragruntOutputWithContext(context.Background()) +} + +func (i StackTerragruntArgs) ToStackTerragruntOutputWithContext(ctx context.Context) StackTerragruntOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackTerragruntOutput) +} + +func (i StackTerragruntArgs) ToOutput(ctx context.Context) pulumix.Output[StackTerragrunt] { + return pulumix.Output[StackTerragrunt]{ + OutputState: i.ToStackTerragruntOutputWithContext(ctx).OutputState, + } +} + +func (i StackTerragruntArgs) ToStackTerragruntPtrOutput() StackTerragruntPtrOutput { + return i.ToStackTerragruntPtrOutputWithContext(context.Background()) +} + +func (i StackTerragruntArgs) ToStackTerragruntPtrOutputWithContext(ctx context.Context) StackTerragruntPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackTerragruntOutput).ToStackTerragruntPtrOutputWithContext(ctx) +} + +// StackTerragruntPtrInput is an input type that accepts StackTerragruntArgs, StackTerragruntPtr and StackTerragruntPtrOutput values. +// You can construct a concrete instance of `StackTerragruntPtrInput` via: +// +// StackTerragruntArgs{...} +// +// or: +// +// nil +type StackTerragruntPtrInput interface { + pulumi.Input + + ToStackTerragruntPtrOutput() StackTerragruntPtrOutput + ToStackTerragruntPtrOutputWithContext(context.Context) StackTerragruntPtrOutput +} + +type stackTerragruntPtrType StackTerragruntArgs + +func StackTerragruntPtr(v *StackTerragruntArgs) StackTerragruntPtrInput { + return (*stackTerragruntPtrType)(v) +} + +func (*stackTerragruntPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**StackTerragrunt)(nil)).Elem() +} + +func (i *stackTerragruntPtrType) ToStackTerragruntPtrOutput() StackTerragruntPtrOutput { + return i.ToStackTerragruntPtrOutputWithContext(context.Background()) +} + +func (i *stackTerragruntPtrType) ToStackTerragruntPtrOutputWithContext(ctx context.Context) StackTerragruntPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackTerragruntPtrOutput) +} + +func (i *stackTerragruntPtrType) ToOutput(ctx context.Context) pulumix.Output[*StackTerragrunt] { + return pulumix.Output[*StackTerragrunt]{ + OutputState: i.ToStackTerragruntPtrOutputWithContext(ctx).OutputState, + } +} + +type StackTerragruntOutput struct{ *pulumi.OutputState } + +func (StackTerragruntOutput) ElementType() reflect.Type { + return reflect.TypeOf((*StackTerragrunt)(nil)).Elem() +} + +func (o StackTerragruntOutput) ToStackTerragruntOutput() StackTerragruntOutput { + return o +} + +func (o StackTerragruntOutput) ToStackTerragruntOutputWithContext(ctx context.Context) StackTerragruntOutput { + return o +} + +func (o StackTerragruntOutput) ToStackTerragruntPtrOutput() StackTerragruntPtrOutput { + return o.ToStackTerragruntPtrOutputWithContext(context.Background()) +} + +func (o StackTerragruntOutput) ToStackTerragruntPtrOutputWithContext(ctx context.Context) StackTerragruntPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v StackTerragrunt) *StackTerragrunt { + return &v + }).(StackTerragruntPtrOutput) +} + +func (o StackTerragruntOutput) ToOutput(ctx context.Context) pulumix.Output[StackTerragrunt] { + return pulumix.Output[StackTerragrunt]{ + OutputState: o.OutputState, + } +} + +func (o StackTerragruntOutput) TerraformVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v StackTerragrunt) *string { return v.TerraformVersion }).(pulumi.StringPtrOutput) +} + +// Terragrunt version. +func (o StackTerragruntOutput) TerragruntVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v StackTerragrunt) *string { return v.TerragruntVersion }).(pulumi.StringPtrOutput) +} + +// Whether to use `terragrunt run-all` instead of `terragrunt`. +func (o StackTerragruntOutput) UseRunAll() pulumi.BoolPtrOutput { + return o.ApplyT(func(v StackTerragrunt) *bool { return v.UseRunAll }).(pulumi.BoolPtrOutput) +} + +func (o StackTerragruntOutput) UseSmartSanitization() pulumi.BoolPtrOutput { + return o.ApplyT(func(v StackTerragrunt) *bool { return v.UseSmartSanitization }).(pulumi.BoolPtrOutput) +} + +type StackTerragruntPtrOutput struct{ *pulumi.OutputState } + +func (StackTerragruntPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**StackTerragrunt)(nil)).Elem() +} + +func (o StackTerragruntPtrOutput) ToStackTerragruntPtrOutput() StackTerragruntPtrOutput { + return o +} + +func (o StackTerragruntPtrOutput) ToStackTerragruntPtrOutputWithContext(ctx context.Context) StackTerragruntPtrOutput { + return o +} + +func (o StackTerragruntPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*StackTerragrunt] { + return pulumix.Output[*StackTerragrunt]{ + OutputState: o.OutputState, + } +} + +func (o StackTerragruntPtrOutput) Elem() StackTerragruntOutput { + return o.ApplyT(func(v *StackTerragrunt) StackTerragrunt { + if v != nil { + return *v + } + var ret StackTerragrunt + return ret + }).(StackTerragruntOutput) +} + +func (o StackTerragruntPtrOutput) TerraformVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *StackTerragrunt) *string { + if v == nil { + return nil + } + return v.TerraformVersion + }).(pulumi.StringPtrOutput) +} + +// Terragrunt version. +func (o StackTerragruntPtrOutput) TerragruntVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *StackTerragrunt) *string { + if v == nil { + return nil + } + return v.TerragruntVersion + }).(pulumi.StringPtrOutput) +} + +// Whether to use `terragrunt run-all` instead of `terragrunt`. +func (o StackTerragruntPtrOutput) UseRunAll() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *StackTerragrunt) *bool { + if v == nil { + return nil + } + return v.UseRunAll + }).(pulumi.BoolPtrOutput) +} + +func (o StackTerragruntPtrOutput) UseSmartSanitization() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *StackTerragrunt) *bool { + if v == nil { + return nil + } + return v.UseSmartSanitization + }).(pulumi.BoolPtrOutput) +} + +type UserPolicy struct { + // Type of access to the space. Possible values are: READ, WRITE, ADMIN + Role string `pulumi:"role"` + // ID (slug) of the space the user has access to + SpaceId string `pulumi:"spaceId"` +} + +// UserPolicyInput is an input type that accepts UserPolicyArgs and UserPolicyOutput values. +// You can construct a concrete instance of `UserPolicyInput` via: +// +// UserPolicyArgs{...} +type UserPolicyInput interface { + pulumi.Input + + ToUserPolicyOutput() UserPolicyOutput + ToUserPolicyOutputWithContext(context.Context) UserPolicyOutput +} + +type UserPolicyArgs struct { + // Type of access to the space. Possible values are: READ, WRITE, ADMIN + Role pulumi.StringInput `pulumi:"role"` + // ID (slug) of the space the user has access to + SpaceId pulumi.StringInput `pulumi:"spaceId"` +} + +func (UserPolicyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*UserPolicy)(nil)).Elem() +} + +func (i UserPolicyArgs) ToUserPolicyOutput() UserPolicyOutput { + return i.ToUserPolicyOutputWithContext(context.Background()) +} + +func (i UserPolicyArgs) ToUserPolicyOutputWithContext(ctx context.Context) UserPolicyOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserPolicyOutput) +} + +func (i UserPolicyArgs) ToOutput(ctx context.Context) pulumix.Output[UserPolicy] { + return pulumix.Output[UserPolicy]{ + OutputState: i.ToUserPolicyOutputWithContext(ctx).OutputState, + } +} + +// UserPolicyArrayInput is an input type that accepts UserPolicyArray and UserPolicyArrayOutput values. +// You can construct a concrete instance of `UserPolicyArrayInput` via: +// +// UserPolicyArray{ UserPolicyArgs{...} } +type UserPolicyArrayInput interface { + pulumi.Input + + ToUserPolicyArrayOutput() UserPolicyArrayOutput + ToUserPolicyArrayOutputWithContext(context.Context) UserPolicyArrayOutput +} + +type UserPolicyArray []UserPolicyInput + +func (UserPolicyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]UserPolicy)(nil)).Elem() +} + +func (i UserPolicyArray) ToUserPolicyArrayOutput() UserPolicyArrayOutput { + return i.ToUserPolicyArrayOutputWithContext(context.Background()) +} + +func (i UserPolicyArray) ToUserPolicyArrayOutputWithContext(ctx context.Context) UserPolicyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserPolicyArrayOutput) +} + +func (i UserPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]UserPolicy] { + return pulumix.Output[[]UserPolicy]{ + OutputState: i.ToUserPolicyArrayOutputWithContext(ctx).OutputState, + } +} + +type UserPolicyOutput struct{ *pulumi.OutputState } + +func (UserPolicyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*UserPolicy)(nil)).Elem() +} + +func (o UserPolicyOutput) ToUserPolicyOutput() UserPolicyOutput { + return o +} + +func (o UserPolicyOutput) ToUserPolicyOutputWithContext(ctx context.Context) UserPolicyOutput { + return o +} + +func (o UserPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[UserPolicy] { + return pulumix.Output[UserPolicy]{ + OutputState: o.OutputState, + } +} + +// Type of access to the space. Possible values are: READ, WRITE, ADMIN +func (o UserPolicyOutput) Role() pulumi.StringOutput { + return o.ApplyT(func(v UserPolicy) string { return v.Role }).(pulumi.StringOutput) +} + +// ID (slug) of the space the user has access to +func (o UserPolicyOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v UserPolicy) string { return v.SpaceId }).(pulumi.StringOutput) +} + +type UserPolicyArrayOutput struct{ *pulumi.OutputState } + +func (UserPolicyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]UserPolicy)(nil)).Elem() +} + +func (o UserPolicyArrayOutput) ToUserPolicyArrayOutput() UserPolicyArrayOutput { + return o +} + +func (o UserPolicyArrayOutput) ToUserPolicyArrayOutputWithContext(ctx context.Context) UserPolicyArrayOutput { + return o +} + +func (o UserPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]UserPolicy] { + return pulumix.Output[[]UserPolicy]{ + OutputState: o.OutputState, + } +} + +func (o UserPolicyArrayOutput) Index(i pulumi.IntInput) UserPolicyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) UserPolicy { + return vs[0].([]UserPolicy)[vs[1].(int)] + }).(UserPolicyOutput) +} + +type GetAwsIntegrationsIntegration struct { + DurationSeconds int `pulumi:"durationSeconds"` + ExternalId string `pulumi:"externalId"` + GenerateCredentialsInWorker bool `pulumi:"generateCredentialsInWorker"` + IntegrationId string `pulumi:"integrationId"` + Labels []string `pulumi:"labels"` + Name string `pulumi:"name"` + RoleArn string `pulumi:"roleArn"` + SpaceId string `pulumi:"spaceId"` +} + +// GetAwsIntegrationsIntegrationInput is an input type that accepts GetAwsIntegrationsIntegrationArgs and GetAwsIntegrationsIntegrationOutput values. +// You can construct a concrete instance of `GetAwsIntegrationsIntegrationInput` via: +// +// GetAwsIntegrationsIntegrationArgs{...} +type GetAwsIntegrationsIntegrationInput interface { + pulumi.Input + + ToGetAwsIntegrationsIntegrationOutput() GetAwsIntegrationsIntegrationOutput + ToGetAwsIntegrationsIntegrationOutputWithContext(context.Context) GetAwsIntegrationsIntegrationOutput +} + +type GetAwsIntegrationsIntegrationArgs struct { + DurationSeconds pulumi.IntInput `pulumi:"durationSeconds"` + ExternalId pulumi.StringInput `pulumi:"externalId"` + GenerateCredentialsInWorker pulumi.BoolInput `pulumi:"generateCredentialsInWorker"` + IntegrationId pulumi.StringInput `pulumi:"integrationId"` + Labels pulumi.StringArrayInput `pulumi:"labels"` + Name pulumi.StringInput `pulumi:"name"` + RoleArn pulumi.StringInput `pulumi:"roleArn"` + SpaceId pulumi.StringInput `pulumi:"spaceId"` +} + +func (GetAwsIntegrationsIntegrationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetAwsIntegrationsIntegration)(nil)).Elem() +} + +func (i GetAwsIntegrationsIntegrationArgs) ToGetAwsIntegrationsIntegrationOutput() GetAwsIntegrationsIntegrationOutput { + return i.ToGetAwsIntegrationsIntegrationOutputWithContext(context.Background()) +} + +func (i GetAwsIntegrationsIntegrationArgs) ToGetAwsIntegrationsIntegrationOutputWithContext(ctx context.Context) GetAwsIntegrationsIntegrationOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetAwsIntegrationsIntegrationOutput) +} + +func (i GetAwsIntegrationsIntegrationArgs) ToOutput(ctx context.Context) pulumix.Output[GetAwsIntegrationsIntegration] { + return pulumix.Output[GetAwsIntegrationsIntegration]{ + OutputState: i.ToGetAwsIntegrationsIntegrationOutputWithContext(ctx).OutputState, + } +} + +// GetAwsIntegrationsIntegrationArrayInput is an input type that accepts GetAwsIntegrationsIntegrationArray and GetAwsIntegrationsIntegrationArrayOutput values. +// You can construct a concrete instance of `GetAwsIntegrationsIntegrationArrayInput` via: +// +// GetAwsIntegrationsIntegrationArray{ GetAwsIntegrationsIntegrationArgs{...} } +type GetAwsIntegrationsIntegrationArrayInput interface { + pulumi.Input + + ToGetAwsIntegrationsIntegrationArrayOutput() GetAwsIntegrationsIntegrationArrayOutput + ToGetAwsIntegrationsIntegrationArrayOutputWithContext(context.Context) GetAwsIntegrationsIntegrationArrayOutput +} + +type GetAwsIntegrationsIntegrationArray []GetAwsIntegrationsIntegrationInput + +func (GetAwsIntegrationsIntegrationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetAwsIntegrationsIntegration)(nil)).Elem() +} + +func (i GetAwsIntegrationsIntegrationArray) ToGetAwsIntegrationsIntegrationArrayOutput() GetAwsIntegrationsIntegrationArrayOutput { + return i.ToGetAwsIntegrationsIntegrationArrayOutputWithContext(context.Background()) +} + +func (i GetAwsIntegrationsIntegrationArray) ToGetAwsIntegrationsIntegrationArrayOutputWithContext(ctx context.Context) GetAwsIntegrationsIntegrationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetAwsIntegrationsIntegrationArrayOutput) +} + +func (i GetAwsIntegrationsIntegrationArray) ToOutput(ctx context.Context) pulumix.Output[[]GetAwsIntegrationsIntegration] { + return pulumix.Output[[]GetAwsIntegrationsIntegration]{ + OutputState: i.ToGetAwsIntegrationsIntegrationArrayOutputWithContext(ctx).OutputState, + } +} + +type GetAwsIntegrationsIntegrationOutput struct{ *pulumi.OutputState } + +func (GetAwsIntegrationsIntegrationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetAwsIntegrationsIntegration)(nil)).Elem() +} + +func (o GetAwsIntegrationsIntegrationOutput) ToGetAwsIntegrationsIntegrationOutput() GetAwsIntegrationsIntegrationOutput { + return o +} + +func (o GetAwsIntegrationsIntegrationOutput) ToGetAwsIntegrationsIntegrationOutputWithContext(ctx context.Context) GetAwsIntegrationsIntegrationOutput { + return o +} + +func (o GetAwsIntegrationsIntegrationOutput) ToOutput(ctx context.Context) pulumix.Output[GetAwsIntegrationsIntegration] { + return pulumix.Output[GetAwsIntegrationsIntegration]{ + OutputState: o.OutputState, + } +} + +func (o GetAwsIntegrationsIntegrationOutput) DurationSeconds() pulumi.IntOutput { + return o.ApplyT(func(v GetAwsIntegrationsIntegration) int { return v.DurationSeconds }).(pulumi.IntOutput) +} + +func (o GetAwsIntegrationsIntegrationOutput) ExternalId() pulumi.StringOutput { + return o.ApplyT(func(v GetAwsIntegrationsIntegration) string { return v.ExternalId }).(pulumi.StringOutput) +} + +func (o GetAwsIntegrationsIntegrationOutput) GenerateCredentialsInWorker() pulumi.BoolOutput { + return o.ApplyT(func(v GetAwsIntegrationsIntegration) bool { return v.GenerateCredentialsInWorker }).(pulumi.BoolOutput) +} + +func (o GetAwsIntegrationsIntegrationOutput) IntegrationId() pulumi.StringOutput { + return o.ApplyT(func(v GetAwsIntegrationsIntegration) string { return v.IntegrationId }).(pulumi.StringOutput) +} + +func (o GetAwsIntegrationsIntegrationOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetAwsIntegrationsIntegration) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +func (o GetAwsIntegrationsIntegrationOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetAwsIntegrationsIntegration) string { return v.Name }).(pulumi.StringOutput) +} + +func (o GetAwsIntegrationsIntegrationOutput) RoleArn() pulumi.StringOutput { + return o.ApplyT(func(v GetAwsIntegrationsIntegration) string { return v.RoleArn }).(pulumi.StringOutput) +} + +func (o GetAwsIntegrationsIntegrationOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v GetAwsIntegrationsIntegration) string { return v.SpaceId }).(pulumi.StringOutput) +} + +type GetAwsIntegrationsIntegrationArrayOutput struct{ *pulumi.OutputState } + +func (GetAwsIntegrationsIntegrationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetAwsIntegrationsIntegration)(nil)).Elem() +} + +func (o GetAwsIntegrationsIntegrationArrayOutput) ToGetAwsIntegrationsIntegrationArrayOutput() GetAwsIntegrationsIntegrationArrayOutput { + return o +} + +func (o GetAwsIntegrationsIntegrationArrayOutput) ToGetAwsIntegrationsIntegrationArrayOutputWithContext(ctx context.Context) GetAwsIntegrationsIntegrationArrayOutput { + return o +} + +func (o GetAwsIntegrationsIntegrationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetAwsIntegrationsIntegration] { + return pulumix.Output[[]GetAwsIntegrationsIntegration]{ + OutputState: o.OutputState, + } +} + +func (o GetAwsIntegrationsIntegrationArrayOutput) Index(i pulumi.IntInput) GetAwsIntegrationsIntegrationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetAwsIntegrationsIntegration { + return vs[0].([]GetAwsIntegrationsIntegration)[vs[1].(int)] + }).(GetAwsIntegrationsIntegrationOutput) +} + +type GetAzureIntegrationsIntegration struct { + AdminConsentProvided bool `pulumi:"adminConsentProvided"` + AdminConsentUrl string `pulumi:"adminConsentUrl"` + ApplicationId string `pulumi:"applicationId"` + DefaultSubscriptionId string `pulumi:"defaultSubscriptionId"` + DisplayName string `pulumi:"displayName"` + IntegrationId string `pulumi:"integrationId"` + Labels []string `pulumi:"labels"` + Name string `pulumi:"name"` + SpaceId string `pulumi:"spaceId"` + TenantId string `pulumi:"tenantId"` +} + +// GetAzureIntegrationsIntegrationInput is an input type that accepts GetAzureIntegrationsIntegrationArgs and GetAzureIntegrationsIntegrationOutput values. +// You can construct a concrete instance of `GetAzureIntegrationsIntegrationInput` via: +// +// GetAzureIntegrationsIntegrationArgs{...} +type GetAzureIntegrationsIntegrationInput interface { + pulumi.Input + + ToGetAzureIntegrationsIntegrationOutput() GetAzureIntegrationsIntegrationOutput + ToGetAzureIntegrationsIntegrationOutputWithContext(context.Context) GetAzureIntegrationsIntegrationOutput +} + +type GetAzureIntegrationsIntegrationArgs struct { + AdminConsentProvided pulumi.BoolInput `pulumi:"adminConsentProvided"` + AdminConsentUrl pulumi.StringInput `pulumi:"adminConsentUrl"` + ApplicationId pulumi.StringInput `pulumi:"applicationId"` + DefaultSubscriptionId pulumi.StringInput `pulumi:"defaultSubscriptionId"` + DisplayName pulumi.StringInput `pulumi:"displayName"` + IntegrationId pulumi.StringInput `pulumi:"integrationId"` + Labels pulumi.StringArrayInput `pulumi:"labels"` + Name pulumi.StringInput `pulumi:"name"` + SpaceId pulumi.StringInput `pulumi:"spaceId"` + TenantId pulumi.StringInput `pulumi:"tenantId"` +} + +func (GetAzureIntegrationsIntegrationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetAzureIntegrationsIntegration)(nil)).Elem() +} + +func (i GetAzureIntegrationsIntegrationArgs) ToGetAzureIntegrationsIntegrationOutput() GetAzureIntegrationsIntegrationOutput { + return i.ToGetAzureIntegrationsIntegrationOutputWithContext(context.Background()) +} + +func (i GetAzureIntegrationsIntegrationArgs) ToGetAzureIntegrationsIntegrationOutputWithContext(ctx context.Context) GetAzureIntegrationsIntegrationOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetAzureIntegrationsIntegrationOutput) +} + +func (i GetAzureIntegrationsIntegrationArgs) ToOutput(ctx context.Context) pulumix.Output[GetAzureIntegrationsIntegration] { + return pulumix.Output[GetAzureIntegrationsIntegration]{ + OutputState: i.ToGetAzureIntegrationsIntegrationOutputWithContext(ctx).OutputState, + } +} + +// GetAzureIntegrationsIntegrationArrayInput is an input type that accepts GetAzureIntegrationsIntegrationArray and GetAzureIntegrationsIntegrationArrayOutput values. +// You can construct a concrete instance of `GetAzureIntegrationsIntegrationArrayInput` via: +// +// GetAzureIntegrationsIntegrationArray{ GetAzureIntegrationsIntegrationArgs{...} } +type GetAzureIntegrationsIntegrationArrayInput interface { + pulumi.Input + + ToGetAzureIntegrationsIntegrationArrayOutput() GetAzureIntegrationsIntegrationArrayOutput + ToGetAzureIntegrationsIntegrationArrayOutputWithContext(context.Context) GetAzureIntegrationsIntegrationArrayOutput +} + +type GetAzureIntegrationsIntegrationArray []GetAzureIntegrationsIntegrationInput + +func (GetAzureIntegrationsIntegrationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetAzureIntegrationsIntegration)(nil)).Elem() +} + +func (i GetAzureIntegrationsIntegrationArray) ToGetAzureIntegrationsIntegrationArrayOutput() GetAzureIntegrationsIntegrationArrayOutput { + return i.ToGetAzureIntegrationsIntegrationArrayOutputWithContext(context.Background()) +} + +func (i GetAzureIntegrationsIntegrationArray) ToGetAzureIntegrationsIntegrationArrayOutputWithContext(ctx context.Context) GetAzureIntegrationsIntegrationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetAzureIntegrationsIntegrationArrayOutput) +} + +func (i GetAzureIntegrationsIntegrationArray) ToOutput(ctx context.Context) pulumix.Output[[]GetAzureIntegrationsIntegration] { + return pulumix.Output[[]GetAzureIntegrationsIntegration]{ + OutputState: i.ToGetAzureIntegrationsIntegrationArrayOutputWithContext(ctx).OutputState, + } +} + +type GetAzureIntegrationsIntegrationOutput struct{ *pulumi.OutputState } + +func (GetAzureIntegrationsIntegrationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetAzureIntegrationsIntegration)(nil)).Elem() +} + +func (o GetAzureIntegrationsIntegrationOutput) ToGetAzureIntegrationsIntegrationOutput() GetAzureIntegrationsIntegrationOutput { + return o +} + +func (o GetAzureIntegrationsIntegrationOutput) ToGetAzureIntegrationsIntegrationOutputWithContext(ctx context.Context) GetAzureIntegrationsIntegrationOutput { + return o +} + +func (o GetAzureIntegrationsIntegrationOutput) ToOutput(ctx context.Context) pulumix.Output[GetAzureIntegrationsIntegration] { + return pulumix.Output[GetAzureIntegrationsIntegration]{ + OutputState: o.OutputState, + } +} + +func (o GetAzureIntegrationsIntegrationOutput) AdminConsentProvided() pulumi.BoolOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) bool { return v.AdminConsentProvided }).(pulumi.BoolOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) AdminConsentUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) string { return v.AdminConsentUrl }).(pulumi.StringOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) ApplicationId() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) string { return v.ApplicationId }).(pulumi.StringOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) DefaultSubscriptionId() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) string { return v.DefaultSubscriptionId }).(pulumi.StringOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) DisplayName() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) string { return v.DisplayName }).(pulumi.StringOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) IntegrationId() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) string { return v.IntegrationId }).(pulumi.StringOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) string { return v.Name }).(pulumi.StringOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) string { return v.SpaceId }).(pulumi.StringOutput) +} + +func (o GetAzureIntegrationsIntegrationOutput) TenantId() pulumi.StringOutput { + return o.ApplyT(func(v GetAzureIntegrationsIntegration) string { return v.TenantId }).(pulumi.StringOutput) +} + +type GetAzureIntegrationsIntegrationArrayOutput struct{ *pulumi.OutputState } + +func (GetAzureIntegrationsIntegrationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetAzureIntegrationsIntegration)(nil)).Elem() +} + +func (o GetAzureIntegrationsIntegrationArrayOutput) ToGetAzureIntegrationsIntegrationArrayOutput() GetAzureIntegrationsIntegrationArrayOutput { + return o +} + +func (o GetAzureIntegrationsIntegrationArrayOutput) ToGetAzureIntegrationsIntegrationArrayOutputWithContext(ctx context.Context) GetAzureIntegrationsIntegrationArrayOutput { + return o +} + +func (o GetAzureIntegrationsIntegrationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetAzureIntegrationsIntegration] { + return pulumix.Output[[]GetAzureIntegrationsIntegration]{ + OutputState: o.OutputState, + } +} + +func (o GetAzureIntegrationsIntegrationArrayOutput) Index(i pulumi.IntInput) GetAzureIntegrationsIntegrationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetAzureIntegrationsIntegration { + return vs[0].([]GetAzureIntegrationsIntegration)[vs[1].(int)] + }).(GetAzureIntegrationsIntegrationOutput) +} + +type GetContextsContext struct { + ContextId string `pulumi:"contextId"` + Description string `pulumi:"description"` + Labels []string `pulumi:"labels"` + Name string `pulumi:"name"` + SpaceId string `pulumi:"spaceId"` +} + +// GetContextsContextInput is an input type that accepts GetContextsContextArgs and GetContextsContextOutput values. +// You can construct a concrete instance of `GetContextsContextInput` via: +// +// GetContextsContextArgs{...} +type GetContextsContextInput interface { + pulumi.Input + + ToGetContextsContextOutput() GetContextsContextOutput + ToGetContextsContextOutputWithContext(context.Context) GetContextsContextOutput +} + +type GetContextsContextArgs struct { + ContextId pulumi.StringInput `pulumi:"contextId"` + Description pulumi.StringInput `pulumi:"description"` + Labels pulumi.StringArrayInput `pulumi:"labels"` + Name pulumi.StringInput `pulumi:"name"` + SpaceId pulumi.StringInput `pulumi:"spaceId"` +} + +func (GetContextsContextArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetContextsContext)(nil)).Elem() +} + +func (i GetContextsContextArgs) ToGetContextsContextOutput() GetContextsContextOutput { + return i.ToGetContextsContextOutputWithContext(context.Background()) +} + +func (i GetContextsContextArgs) ToGetContextsContextOutputWithContext(ctx context.Context) GetContextsContextOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetContextsContextOutput) +} + +func (i GetContextsContextArgs) ToOutput(ctx context.Context) pulumix.Output[GetContextsContext] { + return pulumix.Output[GetContextsContext]{ + OutputState: i.ToGetContextsContextOutputWithContext(ctx).OutputState, + } +} + +// GetContextsContextArrayInput is an input type that accepts GetContextsContextArray and GetContextsContextArrayOutput values. +// You can construct a concrete instance of `GetContextsContextArrayInput` via: +// +// GetContextsContextArray{ GetContextsContextArgs{...} } +type GetContextsContextArrayInput interface { + pulumi.Input + + ToGetContextsContextArrayOutput() GetContextsContextArrayOutput + ToGetContextsContextArrayOutputWithContext(context.Context) GetContextsContextArrayOutput +} + +type GetContextsContextArray []GetContextsContextInput + +func (GetContextsContextArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetContextsContext)(nil)).Elem() +} + +func (i GetContextsContextArray) ToGetContextsContextArrayOutput() GetContextsContextArrayOutput { + return i.ToGetContextsContextArrayOutputWithContext(context.Background()) +} + +func (i GetContextsContextArray) ToGetContextsContextArrayOutputWithContext(ctx context.Context) GetContextsContextArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetContextsContextArrayOutput) +} + +func (i GetContextsContextArray) ToOutput(ctx context.Context) pulumix.Output[[]GetContextsContext] { + return pulumix.Output[[]GetContextsContext]{ + OutputState: i.ToGetContextsContextArrayOutputWithContext(ctx).OutputState, + } +} + +type GetContextsContextOutput struct{ *pulumi.OutputState } + +func (GetContextsContextOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetContextsContext)(nil)).Elem() +} + +func (o GetContextsContextOutput) ToGetContextsContextOutput() GetContextsContextOutput { + return o +} + +func (o GetContextsContextOutput) ToGetContextsContextOutputWithContext(ctx context.Context) GetContextsContextOutput { + return o +} + +func (o GetContextsContextOutput) ToOutput(ctx context.Context) pulumix.Output[GetContextsContext] { + return pulumix.Output[GetContextsContext]{ + OutputState: o.OutputState, + } +} + +func (o GetContextsContextOutput) ContextId() pulumi.StringOutput { + return o.ApplyT(func(v GetContextsContext) string { return v.ContextId }).(pulumi.StringOutput) +} + +func (o GetContextsContextOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetContextsContext) string { return v.Description }).(pulumi.StringOutput) +} + +func (o GetContextsContextOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetContextsContext) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +func (o GetContextsContextOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetContextsContext) string { return v.Name }).(pulumi.StringOutput) +} + +func (o GetContextsContextOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v GetContextsContext) string { return v.SpaceId }).(pulumi.StringOutput) +} + +type GetContextsContextArrayOutput struct{ *pulumi.OutputState } + +func (GetContextsContextArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetContextsContext)(nil)).Elem() +} + +func (o GetContextsContextArrayOutput) ToGetContextsContextArrayOutput() GetContextsContextArrayOutput { + return o +} + +func (o GetContextsContextArrayOutput) ToGetContextsContextArrayOutputWithContext(ctx context.Context) GetContextsContextArrayOutput { + return o +} + +func (o GetContextsContextArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetContextsContext] { + return pulumix.Output[[]GetContextsContext]{ + OutputState: o.OutputState, + } +} + +func (o GetContextsContextArrayOutput) Index(i pulumi.IntInput) GetContextsContextOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetContextsContext { + return vs[0].([]GetContextsContext)[vs[1].(int)] + }).(GetContextsContextOutput) +} + +type GetContextsLabel struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetContextsLabelInput is an input type that accepts GetContextsLabelArgs and GetContextsLabelOutput values. +// You can construct a concrete instance of `GetContextsLabelInput` via: +// +// GetContextsLabelArgs{...} +type GetContextsLabelInput interface { + pulumi.Input + + ToGetContextsLabelOutput() GetContextsLabelOutput + ToGetContextsLabelOutputWithContext(context.Context) GetContextsLabelOutput +} + +type GetContextsLabelArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` +} + +func (GetContextsLabelArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetContextsLabel)(nil)).Elem() +} + +func (i GetContextsLabelArgs) ToGetContextsLabelOutput() GetContextsLabelOutput { + return i.ToGetContextsLabelOutputWithContext(context.Background()) +} + +func (i GetContextsLabelArgs) ToGetContextsLabelOutputWithContext(ctx context.Context) GetContextsLabelOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetContextsLabelOutput) +} + +func (i GetContextsLabelArgs) ToOutput(ctx context.Context) pulumix.Output[GetContextsLabel] { + return pulumix.Output[GetContextsLabel]{ + OutputState: i.ToGetContextsLabelOutputWithContext(ctx).OutputState, + } +} + +// GetContextsLabelArrayInput is an input type that accepts GetContextsLabelArray and GetContextsLabelArrayOutput values. +// You can construct a concrete instance of `GetContextsLabelArrayInput` via: +// +// GetContextsLabelArray{ GetContextsLabelArgs{...} } +type GetContextsLabelArrayInput interface { + pulumi.Input + + ToGetContextsLabelArrayOutput() GetContextsLabelArrayOutput + ToGetContextsLabelArrayOutputWithContext(context.Context) GetContextsLabelArrayOutput +} + +type GetContextsLabelArray []GetContextsLabelInput + +func (GetContextsLabelArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetContextsLabel)(nil)).Elem() +} + +func (i GetContextsLabelArray) ToGetContextsLabelArrayOutput() GetContextsLabelArrayOutput { + return i.ToGetContextsLabelArrayOutputWithContext(context.Background()) +} + +func (i GetContextsLabelArray) ToGetContextsLabelArrayOutputWithContext(ctx context.Context) GetContextsLabelArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetContextsLabelArrayOutput) +} + +func (i GetContextsLabelArray) ToOutput(ctx context.Context) pulumix.Output[[]GetContextsLabel] { + return pulumix.Output[[]GetContextsLabel]{ + OutputState: i.ToGetContextsLabelArrayOutputWithContext(ctx).OutputState, + } +} + +type GetContextsLabelOutput struct{ *pulumi.OutputState } + +func (GetContextsLabelOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetContextsLabel)(nil)).Elem() +} + +func (o GetContextsLabelOutput) ToGetContextsLabelOutput() GetContextsLabelOutput { + return o +} + +func (o GetContextsLabelOutput) ToGetContextsLabelOutputWithContext(ctx context.Context) GetContextsLabelOutput { + return o +} + +func (o GetContextsLabelOutput) ToOutput(ctx context.Context) pulumix.Output[GetContextsLabel] { + return pulumix.Output[GetContextsLabel]{ + OutputState: o.OutputState, + } +} + +func (o GetContextsLabelOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetContextsLabel) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetContextsLabelArrayOutput struct{ *pulumi.OutputState } + +func (GetContextsLabelArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetContextsLabel)(nil)).Elem() +} + +func (o GetContextsLabelArrayOutput) ToGetContextsLabelArrayOutput() GetContextsLabelArrayOutput { + return o +} + +func (o GetContextsLabelArrayOutput) ToGetContextsLabelArrayOutputWithContext(ctx context.Context) GetContextsLabelArrayOutput { + return o +} + +func (o GetContextsLabelArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetContextsLabel] { + return pulumix.Output[[]GetContextsLabel]{ + OutputState: o.OutputState, + } +} + +func (o GetContextsLabelArrayOutput) Index(i pulumi.IntInput) GetContextsLabelOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetContextsLabel { + return vs[0].([]GetContextsLabel)[vs[1].(int)] + }).(GetContextsLabelOutput) +} + +type GetModuleAzureDevop struct { + Project string `pulumi:"project"` +} + +// GetModuleAzureDevopInput is an input type that accepts GetModuleAzureDevopArgs and GetModuleAzureDevopOutput values. +// You can construct a concrete instance of `GetModuleAzureDevopInput` via: +// // GetModuleAzureDevopArgs{...} type GetModuleAzureDevopInput interface { pulumi.Input - ToGetModuleAzureDevopOutput() GetModuleAzureDevopOutput - ToGetModuleAzureDevopOutputWithContext(context.Context) GetModuleAzureDevopOutput + ToGetModuleAzureDevopOutput() GetModuleAzureDevopOutput + ToGetModuleAzureDevopOutputWithContext(context.Context) GetModuleAzureDevopOutput +} + +type GetModuleAzureDevopArgs struct { + Project pulumi.StringInput `pulumi:"project"` +} + +func (GetModuleAzureDevopArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleAzureDevop)(nil)).Elem() +} + +func (i GetModuleAzureDevopArgs) ToGetModuleAzureDevopOutput() GetModuleAzureDevopOutput { + return i.ToGetModuleAzureDevopOutputWithContext(context.Background()) +} + +func (i GetModuleAzureDevopArgs) ToGetModuleAzureDevopOutputWithContext(ctx context.Context) GetModuleAzureDevopOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleAzureDevopOutput) +} + +func (i GetModuleAzureDevopArgs) ToOutput(ctx context.Context) pulumix.Output[GetModuleAzureDevop] { + return pulumix.Output[GetModuleAzureDevop]{ + OutputState: i.ToGetModuleAzureDevopOutputWithContext(ctx).OutputState, + } +} + +// GetModuleAzureDevopArrayInput is an input type that accepts GetModuleAzureDevopArray and GetModuleAzureDevopArrayOutput values. +// You can construct a concrete instance of `GetModuleAzureDevopArrayInput` via: +// +// GetModuleAzureDevopArray{ GetModuleAzureDevopArgs{...} } +type GetModuleAzureDevopArrayInput interface { + pulumi.Input + + ToGetModuleAzureDevopArrayOutput() GetModuleAzureDevopArrayOutput + ToGetModuleAzureDevopArrayOutputWithContext(context.Context) GetModuleAzureDevopArrayOutput +} + +type GetModuleAzureDevopArray []GetModuleAzureDevopInput + +func (GetModuleAzureDevopArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleAzureDevop)(nil)).Elem() +} + +func (i GetModuleAzureDevopArray) ToGetModuleAzureDevopArrayOutput() GetModuleAzureDevopArrayOutput { + return i.ToGetModuleAzureDevopArrayOutputWithContext(context.Background()) +} + +func (i GetModuleAzureDevopArray) ToGetModuleAzureDevopArrayOutputWithContext(ctx context.Context) GetModuleAzureDevopArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleAzureDevopArrayOutput) +} + +func (i GetModuleAzureDevopArray) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleAzureDevop] { + return pulumix.Output[[]GetModuleAzureDevop]{ + OutputState: i.ToGetModuleAzureDevopArrayOutputWithContext(ctx).OutputState, + } +} + +type GetModuleAzureDevopOutput struct{ *pulumi.OutputState } + +func (GetModuleAzureDevopOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleAzureDevop)(nil)).Elem() +} + +func (o GetModuleAzureDevopOutput) ToGetModuleAzureDevopOutput() GetModuleAzureDevopOutput { + return o +} + +func (o GetModuleAzureDevopOutput) ToGetModuleAzureDevopOutputWithContext(ctx context.Context) GetModuleAzureDevopOutput { + return o +} + +func (o GetModuleAzureDevopOutput) ToOutput(ctx context.Context) pulumix.Output[GetModuleAzureDevop] { + return pulumix.Output[GetModuleAzureDevop]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleAzureDevopOutput) Project() pulumi.StringOutput { + return o.ApplyT(func(v GetModuleAzureDevop) string { return v.Project }).(pulumi.StringOutput) +} + +type GetModuleAzureDevopArrayOutput struct{ *pulumi.OutputState } + +func (GetModuleAzureDevopArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleAzureDevop)(nil)).Elem() +} + +func (o GetModuleAzureDevopArrayOutput) ToGetModuleAzureDevopArrayOutput() GetModuleAzureDevopArrayOutput { + return o +} + +func (o GetModuleAzureDevopArrayOutput) ToGetModuleAzureDevopArrayOutputWithContext(ctx context.Context) GetModuleAzureDevopArrayOutput { + return o +} + +func (o GetModuleAzureDevopArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleAzureDevop] { + return pulumix.Output[[]GetModuleAzureDevop]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleAzureDevopArrayOutput) Index(i pulumi.IntInput) GetModuleAzureDevopOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleAzureDevop { + return vs[0].([]GetModuleAzureDevop)[vs[1].(int)] + }).(GetModuleAzureDevopOutput) +} + +type GetModuleBitbucketCloud struct { + Namespace string `pulumi:"namespace"` +} + +// GetModuleBitbucketCloudInput is an input type that accepts GetModuleBitbucketCloudArgs and GetModuleBitbucketCloudOutput values. +// You can construct a concrete instance of `GetModuleBitbucketCloudInput` via: +// +// GetModuleBitbucketCloudArgs{...} +type GetModuleBitbucketCloudInput interface { + pulumi.Input + + ToGetModuleBitbucketCloudOutput() GetModuleBitbucketCloudOutput + ToGetModuleBitbucketCloudOutputWithContext(context.Context) GetModuleBitbucketCloudOutput +} + +type GetModuleBitbucketCloudArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetModuleBitbucketCloudArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleBitbucketCloud)(nil)).Elem() +} + +func (i GetModuleBitbucketCloudArgs) ToGetModuleBitbucketCloudOutput() GetModuleBitbucketCloudOutput { + return i.ToGetModuleBitbucketCloudOutputWithContext(context.Background()) +} + +func (i GetModuleBitbucketCloudArgs) ToGetModuleBitbucketCloudOutputWithContext(ctx context.Context) GetModuleBitbucketCloudOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleBitbucketCloudOutput) +} + +func (i GetModuleBitbucketCloudArgs) ToOutput(ctx context.Context) pulumix.Output[GetModuleBitbucketCloud] { + return pulumix.Output[GetModuleBitbucketCloud]{ + OutputState: i.ToGetModuleBitbucketCloudOutputWithContext(ctx).OutputState, + } +} + +// GetModuleBitbucketCloudArrayInput is an input type that accepts GetModuleBitbucketCloudArray and GetModuleBitbucketCloudArrayOutput values. +// You can construct a concrete instance of `GetModuleBitbucketCloudArrayInput` via: +// +// GetModuleBitbucketCloudArray{ GetModuleBitbucketCloudArgs{...} } +type GetModuleBitbucketCloudArrayInput interface { + pulumi.Input + + ToGetModuleBitbucketCloudArrayOutput() GetModuleBitbucketCloudArrayOutput + ToGetModuleBitbucketCloudArrayOutputWithContext(context.Context) GetModuleBitbucketCloudArrayOutput +} + +type GetModuleBitbucketCloudArray []GetModuleBitbucketCloudInput + +func (GetModuleBitbucketCloudArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleBitbucketCloud)(nil)).Elem() +} + +func (i GetModuleBitbucketCloudArray) ToGetModuleBitbucketCloudArrayOutput() GetModuleBitbucketCloudArrayOutput { + return i.ToGetModuleBitbucketCloudArrayOutputWithContext(context.Background()) +} + +func (i GetModuleBitbucketCloudArray) ToGetModuleBitbucketCloudArrayOutputWithContext(ctx context.Context) GetModuleBitbucketCloudArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleBitbucketCloudArrayOutput) +} + +func (i GetModuleBitbucketCloudArray) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleBitbucketCloud] { + return pulumix.Output[[]GetModuleBitbucketCloud]{ + OutputState: i.ToGetModuleBitbucketCloudArrayOutputWithContext(ctx).OutputState, + } +} + +type GetModuleBitbucketCloudOutput struct{ *pulumi.OutputState } + +func (GetModuleBitbucketCloudOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleBitbucketCloud)(nil)).Elem() +} + +func (o GetModuleBitbucketCloudOutput) ToGetModuleBitbucketCloudOutput() GetModuleBitbucketCloudOutput { + return o +} + +func (o GetModuleBitbucketCloudOutput) ToGetModuleBitbucketCloudOutputWithContext(ctx context.Context) GetModuleBitbucketCloudOutput { + return o +} + +func (o GetModuleBitbucketCloudOutput) ToOutput(ctx context.Context) pulumix.Output[GetModuleBitbucketCloud] { + return pulumix.Output[GetModuleBitbucketCloud]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleBitbucketCloudOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetModuleBitbucketCloud) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetModuleBitbucketCloudArrayOutput struct{ *pulumi.OutputState } + +func (GetModuleBitbucketCloudArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleBitbucketCloud)(nil)).Elem() +} + +func (o GetModuleBitbucketCloudArrayOutput) ToGetModuleBitbucketCloudArrayOutput() GetModuleBitbucketCloudArrayOutput { + return o +} + +func (o GetModuleBitbucketCloudArrayOutput) ToGetModuleBitbucketCloudArrayOutputWithContext(ctx context.Context) GetModuleBitbucketCloudArrayOutput { + return o +} + +func (o GetModuleBitbucketCloudArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleBitbucketCloud] { + return pulumix.Output[[]GetModuleBitbucketCloud]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleBitbucketCloudArrayOutput) Index(i pulumi.IntInput) GetModuleBitbucketCloudOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleBitbucketCloud { + return vs[0].([]GetModuleBitbucketCloud)[vs[1].(int)] + }).(GetModuleBitbucketCloudOutput) +} + +type GetModuleBitbucketDatacenter struct { + Namespace string `pulumi:"namespace"` +} + +// GetModuleBitbucketDatacenterInput is an input type that accepts GetModuleBitbucketDatacenterArgs and GetModuleBitbucketDatacenterOutput values. +// You can construct a concrete instance of `GetModuleBitbucketDatacenterInput` via: +// +// GetModuleBitbucketDatacenterArgs{...} +type GetModuleBitbucketDatacenterInput interface { + pulumi.Input + + ToGetModuleBitbucketDatacenterOutput() GetModuleBitbucketDatacenterOutput + ToGetModuleBitbucketDatacenterOutputWithContext(context.Context) GetModuleBitbucketDatacenterOutput +} + +type GetModuleBitbucketDatacenterArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetModuleBitbucketDatacenterArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleBitbucketDatacenter)(nil)).Elem() +} + +func (i GetModuleBitbucketDatacenterArgs) ToGetModuleBitbucketDatacenterOutput() GetModuleBitbucketDatacenterOutput { + return i.ToGetModuleBitbucketDatacenterOutputWithContext(context.Background()) +} + +func (i GetModuleBitbucketDatacenterArgs) ToGetModuleBitbucketDatacenterOutputWithContext(ctx context.Context) GetModuleBitbucketDatacenterOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleBitbucketDatacenterOutput) +} + +func (i GetModuleBitbucketDatacenterArgs) ToOutput(ctx context.Context) pulumix.Output[GetModuleBitbucketDatacenter] { + return pulumix.Output[GetModuleBitbucketDatacenter]{ + OutputState: i.ToGetModuleBitbucketDatacenterOutputWithContext(ctx).OutputState, + } +} + +// GetModuleBitbucketDatacenterArrayInput is an input type that accepts GetModuleBitbucketDatacenterArray and GetModuleBitbucketDatacenterArrayOutput values. +// You can construct a concrete instance of `GetModuleBitbucketDatacenterArrayInput` via: +// +// GetModuleBitbucketDatacenterArray{ GetModuleBitbucketDatacenterArgs{...} } +type GetModuleBitbucketDatacenterArrayInput interface { + pulumi.Input + + ToGetModuleBitbucketDatacenterArrayOutput() GetModuleBitbucketDatacenterArrayOutput + ToGetModuleBitbucketDatacenterArrayOutputWithContext(context.Context) GetModuleBitbucketDatacenterArrayOutput +} + +type GetModuleBitbucketDatacenterArray []GetModuleBitbucketDatacenterInput + +func (GetModuleBitbucketDatacenterArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleBitbucketDatacenter)(nil)).Elem() +} + +func (i GetModuleBitbucketDatacenterArray) ToGetModuleBitbucketDatacenterArrayOutput() GetModuleBitbucketDatacenterArrayOutput { + return i.ToGetModuleBitbucketDatacenterArrayOutputWithContext(context.Background()) +} + +func (i GetModuleBitbucketDatacenterArray) ToGetModuleBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetModuleBitbucketDatacenterArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleBitbucketDatacenterArrayOutput) +} + +func (i GetModuleBitbucketDatacenterArray) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleBitbucketDatacenter] { + return pulumix.Output[[]GetModuleBitbucketDatacenter]{ + OutputState: i.ToGetModuleBitbucketDatacenterArrayOutputWithContext(ctx).OutputState, + } +} + +type GetModuleBitbucketDatacenterOutput struct{ *pulumi.OutputState } + +func (GetModuleBitbucketDatacenterOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleBitbucketDatacenter)(nil)).Elem() +} + +func (o GetModuleBitbucketDatacenterOutput) ToGetModuleBitbucketDatacenterOutput() GetModuleBitbucketDatacenterOutput { + return o +} + +func (o GetModuleBitbucketDatacenterOutput) ToGetModuleBitbucketDatacenterOutputWithContext(ctx context.Context) GetModuleBitbucketDatacenterOutput { + return o +} + +func (o GetModuleBitbucketDatacenterOutput) ToOutput(ctx context.Context) pulumix.Output[GetModuleBitbucketDatacenter] { + return pulumix.Output[GetModuleBitbucketDatacenter]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleBitbucketDatacenterOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetModuleBitbucketDatacenter) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetModuleBitbucketDatacenterArrayOutput struct{ *pulumi.OutputState } + +func (GetModuleBitbucketDatacenterArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleBitbucketDatacenter)(nil)).Elem() +} + +func (o GetModuleBitbucketDatacenterArrayOutput) ToGetModuleBitbucketDatacenterArrayOutput() GetModuleBitbucketDatacenterArrayOutput { + return o +} + +func (o GetModuleBitbucketDatacenterArrayOutput) ToGetModuleBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetModuleBitbucketDatacenterArrayOutput { + return o +} + +func (o GetModuleBitbucketDatacenterArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleBitbucketDatacenter] { + return pulumix.Output[[]GetModuleBitbucketDatacenter]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleBitbucketDatacenterArrayOutput) Index(i pulumi.IntInput) GetModuleBitbucketDatacenterOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleBitbucketDatacenter { + return vs[0].([]GetModuleBitbucketDatacenter)[vs[1].(int)] + }).(GetModuleBitbucketDatacenterOutput) +} + +type GetModuleGithubEnterprise struct { + Namespace string `pulumi:"namespace"` +} + +// GetModuleGithubEnterpriseInput is an input type that accepts GetModuleGithubEnterpriseArgs and GetModuleGithubEnterpriseOutput values. +// You can construct a concrete instance of `GetModuleGithubEnterpriseInput` via: +// +// GetModuleGithubEnterpriseArgs{...} +type GetModuleGithubEnterpriseInput interface { + pulumi.Input + + ToGetModuleGithubEnterpriseOutput() GetModuleGithubEnterpriseOutput + ToGetModuleGithubEnterpriseOutputWithContext(context.Context) GetModuleGithubEnterpriseOutput +} + +type GetModuleGithubEnterpriseArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetModuleGithubEnterpriseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleGithubEnterprise)(nil)).Elem() +} + +func (i GetModuleGithubEnterpriseArgs) ToGetModuleGithubEnterpriseOutput() GetModuleGithubEnterpriseOutput { + return i.ToGetModuleGithubEnterpriseOutputWithContext(context.Background()) +} + +func (i GetModuleGithubEnterpriseArgs) ToGetModuleGithubEnterpriseOutputWithContext(ctx context.Context) GetModuleGithubEnterpriseOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleGithubEnterpriseOutput) +} + +func (i GetModuleGithubEnterpriseArgs) ToOutput(ctx context.Context) pulumix.Output[GetModuleGithubEnterprise] { + return pulumix.Output[GetModuleGithubEnterprise]{ + OutputState: i.ToGetModuleGithubEnterpriseOutputWithContext(ctx).OutputState, + } +} + +// GetModuleGithubEnterpriseArrayInput is an input type that accepts GetModuleGithubEnterpriseArray and GetModuleGithubEnterpriseArrayOutput values. +// You can construct a concrete instance of `GetModuleGithubEnterpriseArrayInput` via: +// +// GetModuleGithubEnterpriseArray{ GetModuleGithubEnterpriseArgs{...} } +type GetModuleGithubEnterpriseArrayInput interface { + pulumi.Input + + ToGetModuleGithubEnterpriseArrayOutput() GetModuleGithubEnterpriseArrayOutput + ToGetModuleGithubEnterpriseArrayOutputWithContext(context.Context) GetModuleGithubEnterpriseArrayOutput +} + +type GetModuleGithubEnterpriseArray []GetModuleGithubEnterpriseInput + +func (GetModuleGithubEnterpriseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleGithubEnterprise)(nil)).Elem() +} + +func (i GetModuleGithubEnterpriseArray) ToGetModuleGithubEnterpriseArrayOutput() GetModuleGithubEnterpriseArrayOutput { + return i.ToGetModuleGithubEnterpriseArrayOutputWithContext(context.Background()) +} + +func (i GetModuleGithubEnterpriseArray) ToGetModuleGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetModuleGithubEnterpriseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleGithubEnterpriseArrayOutput) +} + +func (i GetModuleGithubEnterpriseArray) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleGithubEnterprise] { + return pulumix.Output[[]GetModuleGithubEnterprise]{ + OutputState: i.ToGetModuleGithubEnterpriseArrayOutputWithContext(ctx).OutputState, + } +} + +type GetModuleGithubEnterpriseOutput struct{ *pulumi.OutputState } + +func (GetModuleGithubEnterpriseOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleGithubEnterprise)(nil)).Elem() +} + +func (o GetModuleGithubEnterpriseOutput) ToGetModuleGithubEnterpriseOutput() GetModuleGithubEnterpriseOutput { + return o +} + +func (o GetModuleGithubEnterpriseOutput) ToGetModuleGithubEnterpriseOutputWithContext(ctx context.Context) GetModuleGithubEnterpriseOutput { + return o +} + +func (o GetModuleGithubEnterpriseOutput) ToOutput(ctx context.Context) pulumix.Output[GetModuleGithubEnterprise] { + return pulumix.Output[GetModuleGithubEnterprise]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleGithubEnterpriseOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetModuleGithubEnterprise) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetModuleGithubEnterpriseArrayOutput struct{ *pulumi.OutputState } + +func (GetModuleGithubEnterpriseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleGithubEnterprise)(nil)).Elem() +} + +func (o GetModuleGithubEnterpriseArrayOutput) ToGetModuleGithubEnterpriseArrayOutput() GetModuleGithubEnterpriseArrayOutput { + return o +} + +func (o GetModuleGithubEnterpriseArrayOutput) ToGetModuleGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetModuleGithubEnterpriseArrayOutput { + return o +} + +func (o GetModuleGithubEnterpriseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleGithubEnterprise] { + return pulumix.Output[[]GetModuleGithubEnterprise]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleGithubEnterpriseArrayOutput) Index(i pulumi.IntInput) GetModuleGithubEnterpriseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleGithubEnterprise { + return vs[0].([]GetModuleGithubEnterprise)[vs[1].(int)] + }).(GetModuleGithubEnterpriseOutput) +} + +type GetModuleGitlab struct { + Namespace string `pulumi:"namespace"` +} + +// GetModuleGitlabInput is an input type that accepts GetModuleGitlabArgs and GetModuleGitlabOutput values. +// You can construct a concrete instance of `GetModuleGitlabInput` via: +// +// GetModuleGitlabArgs{...} +type GetModuleGitlabInput interface { + pulumi.Input + + ToGetModuleGitlabOutput() GetModuleGitlabOutput + ToGetModuleGitlabOutputWithContext(context.Context) GetModuleGitlabOutput +} + +type GetModuleGitlabArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetModuleGitlabArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleGitlab)(nil)).Elem() +} + +func (i GetModuleGitlabArgs) ToGetModuleGitlabOutput() GetModuleGitlabOutput { + return i.ToGetModuleGitlabOutputWithContext(context.Background()) +} + +func (i GetModuleGitlabArgs) ToGetModuleGitlabOutputWithContext(ctx context.Context) GetModuleGitlabOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleGitlabOutput) +} + +func (i GetModuleGitlabArgs) ToOutput(ctx context.Context) pulumix.Output[GetModuleGitlab] { + return pulumix.Output[GetModuleGitlab]{ + OutputState: i.ToGetModuleGitlabOutputWithContext(ctx).OutputState, + } +} + +// GetModuleGitlabArrayInput is an input type that accepts GetModuleGitlabArray and GetModuleGitlabArrayOutput values. +// You can construct a concrete instance of `GetModuleGitlabArrayInput` via: +// +// GetModuleGitlabArray{ GetModuleGitlabArgs{...} } +type GetModuleGitlabArrayInput interface { + pulumi.Input + + ToGetModuleGitlabArrayOutput() GetModuleGitlabArrayOutput + ToGetModuleGitlabArrayOutputWithContext(context.Context) GetModuleGitlabArrayOutput +} + +type GetModuleGitlabArray []GetModuleGitlabInput + +func (GetModuleGitlabArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleGitlab)(nil)).Elem() +} + +func (i GetModuleGitlabArray) ToGetModuleGitlabArrayOutput() GetModuleGitlabArrayOutput { + return i.ToGetModuleGitlabArrayOutputWithContext(context.Background()) +} + +func (i GetModuleGitlabArray) ToGetModuleGitlabArrayOutputWithContext(ctx context.Context) GetModuleGitlabArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetModuleGitlabArrayOutput) +} + +func (i GetModuleGitlabArray) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleGitlab] { + return pulumix.Output[[]GetModuleGitlab]{ + OutputState: i.ToGetModuleGitlabArrayOutputWithContext(ctx).OutputState, + } +} + +type GetModuleGitlabOutput struct{ *pulumi.OutputState } + +func (GetModuleGitlabOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetModuleGitlab)(nil)).Elem() +} + +func (o GetModuleGitlabOutput) ToGetModuleGitlabOutput() GetModuleGitlabOutput { + return o +} + +func (o GetModuleGitlabOutput) ToGetModuleGitlabOutputWithContext(ctx context.Context) GetModuleGitlabOutput { + return o +} + +func (o GetModuleGitlabOutput) ToOutput(ctx context.Context) pulumix.Output[GetModuleGitlab] { + return pulumix.Output[GetModuleGitlab]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleGitlabOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetModuleGitlab) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetModuleGitlabArrayOutput struct{ *pulumi.OutputState } + +func (GetModuleGitlabArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetModuleGitlab)(nil)).Elem() +} + +func (o GetModuleGitlabArrayOutput) ToGetModuleGitlabArrayOutput() GetModuleGitlabArrayOutput { + return o +} + +func (o GetModuleGitlabArrayOutput) ToGetModuleGitlabArrayOutputWithContext(ctx context.Context) GetModuleGitlabArrayOutput { + return o +} + +func (o GetModuleGitlabArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetModuleGitlab] { + return pulumix.Output[[]GetModuleGitlab]{ + OutputState: o.OutputState, + } +} + +func (o GetModuleGitlabArrayOutput) Index(i pulumi.IntInput) GetModuleGitlabOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleGitlab { + return vs[0].([]GetModuleGitlab)[vs[1].(int)] + }).(GetModuleGitlabOutput) +} + +type GetPoliciesPolicy struct { + Id string `pulumi:"id"` + Labels []string `pulumi:"labels"` + Name string `pulumi:"name"` + SpaceId string `pulumi:"spaceId"` + Type string `pulumi:"type"` +} + +// GetPoliciesPolicyInput is an input type that accepts GetPoliciesPolicyArgs and GetPoliciesPolicyOutput values. +// You can construct a concrete instance of `GetPoliciesPolicyInput` via: +// +// GetPoliciesPolicyArgs{...} +type GetPoliciesPolicyInput interface { + pulumi.Input + + ToGetPoliciesPolicyOutput() GetPoliciesPolicyOutput + ToGetPoliciesPolicyOutputWithContext(context.Context) GetPoliciesPolicyOutput +} + +type GetPoliciesPolicyArgs struct { + Id pulumi.StringInput `pulumi:"id"` + Labels pulumi.StringArrayInput `pulumi:"labels"` + Name pulumi.StringInput `pulumi:"name"` + SpaceId pulumi.StringInput `pulumi:"spaceId"` + Type pulumi.StringInput `pulumi:"type"` +} + +func (GetPoliciesPolicyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetPoliciesPolicy)(nil)).Elem() +} + +func (i GetPoliciesPolicyArgs) ToGetPoliciesPolicyOutput() GetPoliciesPolicyOutput { + return i.ToGetPoliciesPolicyOutputWithContext(context.Background()) +} + +func (i GetPoliciesPolicyArgs) ToGetPoliciesPolicyOutputWithContext(ctx context.Context) GetPoliciesPolicyOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetPoliciesPolicyOutput) +} + +func (i GetPoliciesPolicyArgs) ToOutput(ctx context.Context) pulumix.Output[GetPoliciesPolicy] { + return pulumix.Output[GetPoliciesPolicy]{ + OutputState: i.ToGetPoliciesPolicyOutputWithContext(ctx).OutputState, + } +} + +// GetPoliciesPolicyArrayInput is an input type that accepts GetPoliciesPolicyArray and GetPoliciesPolicyArrayOutput values. +// You can construct a concrete instance of `GetPoliciesPolicyArrayInput` via: +// +// GetPoliciesPolicyArray{ GetPoliciesPolicyArgs{...} } +type GetPoliciesPolicyArrayInput interface { + pulumi.Input + + ToGetPoliciesPolicyArrayOutput() GetPoliciesPolicyArrayOutput + ToGetPoliciesPolicyArrayOutputWithContext(context.Context) GetPoliciesPolicyArrayOutput +} + +type GetPoliciesPolicyArray []GetPoliciesPolicyInput + +func (GetPoliciesPolicyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetPoliciesPolicy)(nil)).Elem() +} + +func (i GetPoliciesPolicyArray) ToGetPoliciesPolicyArrayOutput() GetPoliciesPolicyArrayOutput { + return i.ToGetPoliciesPolicyArrayOutputWithContext(context.Background()) +} + +func (i GetPoliciesPolicyArray) ToGetPoliciesPolicyArrayOutputWithContext(ctx context.Context) GetPoliciesPolicyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetPoliciesPolicyArrayOutput) +} + +func (i GetPoliciesPolicyArray) ToOutput(ctx context.Context) pulumix.Output[[]GetPoliciesPolicy] { + return pulumix.Output[[]GetPoliciesPolicy]{ + OutputState: i.ToGetPoliciesPolicyArrayOutputWithContext(ctx).OutputState, + } +} + +type GetPoliciesPolicyOutput struct{ *pulumi.OutputState } + +func (GetPoliciesPolicyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetPoliciesPolicy)(nil)).Elem() +} + +func (o GetPoliciesPolicyOutput) ToGetPoliciesPolicyOutput() GetPoliciesPolicyOutput { + return o +} + +func (o GetPoliciesPolicyOutput) ToGetPoliciesPolicyOutputWithContext(ctx context.Context) GetPoliciesPolicyOutput { + return o +} + +func (o GetPoliciesPolicyOutput) ToOutput(ctx context.Context) pulumix.Output[GetPoliciesPolicy] { + return pulumix.Output[GetPoliciesPolicy]{ + OutputState: o.OutputState, + } +} + +func (o GetPoliciesPolicyOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetPoliciesPolicy) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetPoliciesPolicyOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetPoliciesPolicy) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +func (o GetPoliciesPolicyOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetPoliciesPolicy) string { return v.Name }).(pulumi.StringOutput) +} + +func (o GetPoliciesPolicyOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v GetPoliciesPolicy) string { return v.SpaceId }).(pulumi.StringOutput) +} + +func (o GetPoliciesPolicyOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetPoliciesPolicy) string { return v.Type }).(pulumi.StringOutput) +} + +type GetPoliciesPolicyArrayOutput struct{ *pulumi.OutputState } + +func (GetPoliciesPolicyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetPoliciesPolicy)(nil)).Elem() +} + +func (o GetPoliciesPolicyArrayOutput) ToGetPoliciesPolicyArrayOutput() GetPoliciesPolicyArrayOutput { + return o +} + +func (o GetPoliciesPolicyArrayOutput) ToGetPoliciesPolicyArrayOutputWithContext(ctx context.Context) GetPoliciesPolicyArrayOutput { + return o +} + +func (o GetPoliciesPolicyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetPoliciesPolicy] { + return pulumix.Output[[]GetPoliciesPolicy]{ + OutputState: o.OutputState, + } +} + +func (o GetPoliciesPolicyArrayOutput) Index(i pulumi.IntInput) GetPoliciesPolicyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoliciesPolicy { + return vs[0].([]GetPoliciesPolicy)[vs[1].(int)] + }).(GetPoliciesPolicyOutput) +} + +type GetSpacesSpace struct { + Description string `pulumi:"description"` + InheritEntities bool `pulumi:"inheritEntities"` + Labels []string `pulumi:"labels"` + Name string `pulumi:"name"` + ParentSpaceId string `pulumi:"parentSpaceId"` + SpaceId string `pulumi:"spaceId"` +} + +// GetSpacesSpaceInput is an input type that accepts GetSpacesSpaceArgs and GetSpacesSpaceOutput values. +// You can construct a concrete instance of `GetSpacesSpaceInput` via: +// +// GetSpacesSpaceArgs{...} +type GetSpacesSpaceInput interface { + pulumi.Input + + ToGetSpacesSpaceOutput() GetSpacesSpaceOutput + ToGetSpacesSpaceOutputWithContext(context.Context) GetSpacesSpaceOutput +} + +type GetSpacesSpaceArgs struct { + Description pulumi.StringInput `pulumi:"description"` + InheritEntities pulumi.BoolInput `pulumi:"inheritEntities"` + Labels pulumi.StringArrayInput `pulumi:"labels"` + Name pulumi.StringInput `pulumi:"name"` + ParentSpaceId pulumi.StringInput `pulumi:"parentSpaceId"` + SpaceId pulumi.StringInput `pulumi:"spaceId"` +} + +func (GetSpacesSpaceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSpacesSpace)(nil)).Elem() +} + +func (i GetSpacesSpaceArgs) ToGetSpacesSpaceOutput() GetSpacesSpaceOutput { + return i.ToGetSpacesSpaceOutputWithContext(context.Background()) +} + +func (i GetSpacesSpaceArgs) ToGetSpacesSpaceOutputWithContext(ctx context.Context) GetSpacesSpaceOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSpacesSpaceOutput) +} + +func (i GetSpacesSpaceArgs) ToOutput(ctx context.Context) pulumix.Output[GetSpacesSpace] { + return pulumix.Output[GetSpacesSpace]{ + OutputState: i.ToGetSpacesSpaceOutputWithContext(ctx).OutputState, + } +} + +// GetSpacesSpaceArrayInput is an input type that accepts GetSpacesSpaceArray and GetSpacesSpaceArrayOutput values. +// You can construct a concrete instance of `GetSpacesSpaceArrayInput` via: +// +// GetSpacesSpaceArray{ GetSpacesSpaceArgs{...} } +type GetSpacesSpaceArrayInput interface { + pulumi.Input + + ToGetSpacesSpaceArrayOutput() GetSpacesSpaceArrayOutput + ToGetSpacesSpaceArrayOutputWithContext(context.Context) GetSpacesSpaceArrayOutput +} + +type GetSpacesSpaceArray []GetSpacesSpaceInput + +func (GetSpacesSpaceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetSpacesSpace)(nil)).Elem() +} + +func (i GetSpacesSpaceArray) ToGetSpacesSpaceArrayOutput() GetSpacesSpaceArrayOutput { + return i.ToGetSpacesSpaceArrayOutputWithContext(context.Background()) +} + +func (i GetSpacesSpaceArray) ToGetSpacesSpaceArrayOutputWithContext(ctx context.Context) GetSpacesSpaceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSpacesSpaceArrayOutput) +} + +func (i GetSpacesSpaceArray) ToOutput(ctx context.Context) pulumix.Output[[]GetSpacesSpace] { + return pulumix.Output[[]GetSpacesSpace]{ + OutputState: i.ToGetSpacesSpaceArrayOutputWithContext(ctx).OutputState, + } +} + +type GetSpacesSpaceOutput struct{ *pulumi.OutputState } + +func (GetSpacesSpaceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSpacesSpace)(nil)).Elem() +} + +func (o GetSpacesSpaceOutput) ToGetSpacesSpaceOutput() GetSpacesSpaceOutput { + return o +} + +func (o GetSpacesSpaceOutput) ToGetSpacesSpaceOutputWithContext(ctx context.Context) GetSpacesSpaceOutput { + return o +} + +func (o GetSpacesSpaceOutput) ToOutput(ctx context.Context) pulumix.Output[GetSpacesSpace] { + return pulumix.Output[GetSpacesSpace]{ + OutputState: o.OutputState, + } +} + +func (o GetSpacesSpaceOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetSpacesSpace) string { return v.Description }).(pulumi.StringOutput) +} + +func (o GetSpacesSpaceOutput) InheritEntities() pulumi.BoolOutput { + return o.ApplyT(func(v GetSpacesSpace) bool { return v.InheritEntities }).(pulumi.BoolOutput) +} + +func (o GetSpacesSpaceOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetSpacesSpace) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +func (o GetSpacesSpaceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetSpacesSpace) string { return v.Name }).(pulumi.StringOutput) +} + +func (o GetSpacesSpaceOutput) ParentSpaceId() pulumi.StringOutput { + return o.ApplyT(func(v GetSpacesSpace) string { return v.ParentSpaceId }).(pulumi.StringOutput) +} + +func (o GetSpacesSpaceOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v GetSpacesSpace) string { return v.SpaceId }).(pulumi.StringOutput) +} + +type GetSpacesSpaceArrayOutput struct{ *pulumi.OutputState } + +func (GetSpacesSpaceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetSpacesSpace)(nil)).Elem() +} + +func (o GetSpacesSpaceArrayOutput) ToGetSpacesSpaceArrayOutput() GetSpacesSpaceArrayOutput { + return o +} + +func (o GetSpacesSpaceArrayOutput) ToGetSpacesSpaceArrayOutputWithContext(ctx context.Context) GetSpacesSpaceArrayOutput { + return o +} + +func (o GetSpacesSpaceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetSpacesSpace] { + return pulumix.Output[[]GetSpacesSpace]{ + OutputState: o.OutputState, + } +} + +func (o GetSpacesSpaceArrayOutput) Index(i pulumi.IntInput) GetSpacesSpaceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetSpacesSpace { + return vs[0].([]GetSpacesSpace)[vs[1].(int)] + }).(GetSpacesSpaceOutput) +} + +type GetStackAnsible struct { + Playbook string `pulumi:"playbook"` +} + +// GetStackAnsibleInput is an input type that accepts GetStackAnsibleArgs and GetStackAnsibleOutput values. +// You can construct a concrete instance of `GetStackAnsibleInput` via: +// +// GetStackAnsibleArgs{...} +type GetStackAnsibleInput interface { + pulumi.Input + + ToGetStackAnsibleOutput() GetStackAnsibleOutput + ToGetStackAnsibleOutputWithContext(context.Context) GetStackAnsibleOutput +} + +type GetStackAnsibleArgs struct { + Playbook pulumi.StringInput `pulumi:"playbook"` +} + +func (GetStackAnsibleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackAnsible)(nil)).Elem() +} + +func (i GetStackAnsibleArgs) ToGetStackAnsibleOutput() GetStackAnsibleOutput { + return i.ToGetStackAnsibleOutputWithContext(context.Background()) +} + +func (i GetStackAnsibleArgs) ToGetStackAnsibleOutputWithContext(ctx context.Context) GetStackAnsibleOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackAnsibleOutput) +} + +func (i GetStackAnsibleArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackAnsible] { + return pulumix.Output[GetStackAnsible]{ + OutputState: i.ToGetStackAnsibleOutputWithContext(ctx).OutputState, + } +} + +// GetStackAnsibleArrayInput is an input type that accepts GetStackAnsibleArray and GetStackAnsibleArrayOutput values. +// You can construct a concrete instance of `GetStackAnsibleArrayInput` via: +// +// GetStackAnsibleArray{ GetStackAnsibleArgs{...} } +type GetStackAnsibleArrayInput interface { + pulumi.Input + + ToGetStackAnsibleArrayOutput() GetStackAnsibleArrayOutput + ToGetStackAnsibleArrayOutputWithContext(context.Context) GetStackAnsibleArrayOutput +} + +type GetStackAnsibleArray []GetStackAnsibleInput + +func (GetStackAnsibleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackAnsible)(nil)).Elem() +} + +func (i GetStackAnsibleArray) ToGetStackAnsibleArrayOutput() GetStackAnsibleArrayOutput { + return i.ToGetStackAnsibleArrayOutputWithContext(context.Background()) +} + +func (i GetStackAnsibleArray) ToGetStackAnsibleArrayOutputWithContext(ctx context.Context) GetStackAnsibleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackAnsibleArrayOutput) +} + +func (i GetStackAnsibleArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackAnsible] { + return pulumix.Output[[]GetStackAnsible]{ + OutputState: i.ToGetStackAnsibleArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackAnsibleOutput struct{ *pulumi.OutputState } + +func (GetStackAnsibleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackAnsible)(nil)).Elem() +} + +func (o GetStackAnsibleOutput) ToGetStackAnsibleOutput() GetStackAnsibleOutput { + return o +} + +func (o GetStackAnsibleOutput) ToGetStackAnsibleOutputWithContext(ctx context.Context) GetStackAnsibleOutput { + return o +} + +func (o GetStackAnsibleOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackAnsible] { + return pulumix.Output[GetStackAnsible]{ + OutputState: o.OutputState, + } +} + +func (o GetStackAnsibleOutput) Playbook() pulumi.StringOutput { + return o.ApplyT(func(v GetStackAnsible) string { return v.Playbook }).(pulumi.StringOutput) +} + +type GetStackAnsibleArrayOutput struct{ *pulumi.OutputState } + +func (GetStackAnsibleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackAnsible)(nil)).Elem() +} + +func (o GetStackAnsibleArrayOutput) ToGetStackAnsibleArrayOutput() GetStackAnsibleArrayOutput { + return o +} + +func (o GetStackAnsibleArrayOutput) ToGetStackAnsibleArrayOutputWithContext(ctx context.Context) GetStackAnsibleArrayOutput { + return o +} + +func (o GetStackAnsibleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackAnsible] { + return pulumix.Output[[]GetStackAnsible]{ + OutputState: o.OutputState, + } +} + +func (o GetStackAnsibleArrayOutput) Index(i pulumi.IntInput) GetStackAnsibleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackAnsible { + return vs[0].([]GetStackAnsible)[vs[1].(int)] + }).(GetStackAnsibleOutput) +} + +type GetStackAzureDevop struct { + Project string `pulumi:"project"` +} + +// GetStackAzureDevopInput is an input type that accepts GetStackAzureDevopArgs and GetStackAzureDevopOutput values. +// You can construct a concrete instance of `GetStackAzureDevopInput` via: +// +// GetStackAzureDevopArgs{...} +type GetStackAzureDevopInput interface { + pulumi.Input + + ToGetStackAzureDevopOutput() GetStackAzureDevopOutput + ToGetStackAzureDevopOutputWithContext(context.Context) GetStackAzureDevopOutput +} + +type GetStackAzureDevopArgs struct { + Project pulumi.StringInput `pulumi:"project"` +} + +func (GetStackAzureDevopArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackAzureDevop)(nil)).Elem() +} + +func (i GetStackAzureDevopArgs) ToGetStackAzureDevopOutput() GetStackAzureDevopOutput { + return i.ToGetStackAzureDevopOutputWithContext(context.Background()) +} + +func (i GetStackAzureDevopArgs) ToGetStackAzureDevopOutputWithContext(ctx context.Context) GetStackAzureDevopOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackAzureDevopOutput) +} + +func (i GetStackAzureDevopArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackAzureDevop] { + return pulumix.Output[GetStackAzureDevop]{ + OutputState: i.ToGetStackAzureDevopOutputWithContext(ctx).OutputState, + } +} + +// GetStackAzureDevopArrayInput is an input type that accepts GetStackAzureDevopArray and GetStackAzureDevopArrayOutput values. +// You can construct a concrete instance of `GetStackAzureDevopArrayInput` via: +// +// GetStackAzureDevopArray{ GetStackAzureDevopArgs{...} } +type GetStackAzureDevopArrayInput interface { + pulumi.Input + + ToGetStackAzureDevopArrayOutput() GetStackAzureDevopArrayOutput + ToGetStackAzureDevopArrayOutputWithContext(context.Context) GetStackAzureDevopArrayOutput +} + +type GetStackAzureDevopArray []GetStackAzureDevopInput + +func (GetStackAzureDevopArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackAzureDevop)(nil)).Elem() +} + +func (i GetStackAzureDevopArray) ToGetStackAzureDevopArrayOutput() GetStackAzureDevopArrayOutput { + return i.ToGetStackAzureDevopArrayOutputWithContext(context.Background()) +} + +func (i GetStackAzureDevopArray) ToGetStackAzureDevopArrayOutputWithContext(ctx context.Context) GetStackAzureDevopArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackAzureDevopArrayOutput) +} + +func (i GetStackAzureDevopArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackAzureDevop] { + return pulumix.Output[[]GetStackAzureDevop]{ + OutputState: i.ToGetStackAzureDevopArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackAzureDevopOutput struct{ *pulumi.OutputState } + +func (GetStackAzureDevopOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackAzureDevop)(nil)).Elem() +} + +func (o GetStackAzureDevopOutput) ToGetStackAzureDevopOutput() GetStackAzureDevopOutput { + return o +} + +func (o GetStackAzureDevopOutput) ToGetStackAzureDevopOutputWithContext(ctx context.Context) GetStackAzureDevopOutput { + return o +} + +func (o GetStackAzureDevopOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackAzureDevop] { + return pulumix.Output[GetStackAzureDevop]{ + OutputState: o.OutputState, + } +} + +func (o GetStackAzureDevopOutput) Project() pulumi.StringOutput { + return o.ApplyT(func(v GetStackAzureDevop) string { return v.Project }).(pulumi.StringOutput) +} + +type GetStackAzureDevopArrayOutput struct{ *pulumi.OutputState } + +func (GetStackAzureDevopArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackAzureDevop)(nil)).Elem() +} + +func (o GetStackAzureDevopArrayOutput) ToGetStackAzureDevopArrayOutput() GetStackAzureDevopArrayOutput { + return o +} + +func (o GetStackAzureDevopArrayOutput) ToGetStackAzureDevopArrayOutputWithContext(ctx context.Context) GetStackAzureDevopArrayOutput { + return o +} + +func (o GetStackAzureDevopArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackAzureDevop] { + return pulumix.Output[[]GetStackAzureDevop]{ + OutputState: o.OutputState, + } +} + +func (o GetStackAzureDevopArrayOutput) Index(i pulumi.IntInput) GetStackAzureDevopOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackAzureDevop { + return vs[0].([]GetStackAzureDevop)[vs[1].(int)] + }).(GetStackAzureDevopOutput) +} + +type GetStackBitbucketCloud struct { + Namespace string `pulumi:"namespace"` +} + +// GetStackBitbucketCloudInput is an input type that accepts GetStackBitbucketCloudArgs and GetStackBitbucketCloudOutput values. +// You can construct a concrete instance of `GetStackBitbucketCloudInput` via: +// +// GetStackBitbucketCloudArgs{...} +type GetStackBitbucketCloudInput interface { + pulumi.Input + + ToGetStackBitbucketCloudOutput() GetStackBitbucketCloudOutput + ToGetStackBitbucketCloudOutputWithContext(context.Context) GetStackBitbucketCloudOutput +} + +type GetStackBitbucketCloudArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetStackBitbucketCloudArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackBitbucketCloud)(nil)).Elem() +} + +func (i GetStackBitbucketCloudArgs) ToGetStackBitbucketCloudOutput() GetStackBitbucketCloudOutput { + return i.ToGetStackBitbucketCloudOutputWithContext(context.Background()) +} + +func (i GetStackBitbucketCloudArgs) ToGetStackBitbucketCloudOutputWithContext(ctx context.Context) GetStackBitbucketCloudOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackBitbucketCloudOutput) +} + +func (i GetStackBitbucketCloudArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackBitbucketCloud] { + return pulumix.Output[GetStackBitbucketCloud]{ + OutputState: i.ToGetStackBitbucketCloudOutputWithContext(ctx).OutputState, + } +} + +// GetStackBitbucketCloudArrayInput is an input type that accepts GetStackBitbucketCloudArray and GetStackBitbucketCloudArrayOutput values. +// You can construct a concrete instance of `GetStackBitbucketCloudArrayInput` via: +// +// GetStackBitbucketCloudArray{ GetStackBitbucketCloudArgs{...} } +type GetStackBitbucketCloudArrayInput interface { + pulumi.Input + + ToGetStackBitbucketCloudArrayOutput() GetStackBitbucketCloudArrayOutput + ToGetStackBitbucketCloudArrayOutputWithContext(context.Context) GetStackBitbucketCloudArrayOutput +} + +type GetStackBitbucketCloudArray []GetStackBitbucketCloudInput + +func (GetStackBitbucketCloudArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackBitbucketCloud)(nil)).Elem() +} + +func (i GetStackBitbucketCloudArray) ToGetStackBitbucketCloudArrayOutput() GetStackBitbucketCloudArrayOutput { + return i.ToGetStackBitbucketCloudArrayOutputWithContext(context.Background()) +} + +func (i GetStackBitbucketCloudArray) ToGetStackBitbucketCloudArrayOutputWithContext(ctx context.Context) GetStackBitbucketCloudArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackBitbucketCloudArrayOutput) +} + +func (i GetStackBitbucketCloudArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackBitbucketCloud] { + return pulumix.Output[[]GetStackBitbucketCloud]{ + OutputState: i.ToGetStackBitbucketCloudArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackBitbucketCloudOutput struct{ *pulumi.OutputState } + +func (GetStackBitbucketCloudOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackBitbucketCloud)(nil)).Elem() +} + +func (o GetStackBitbucketCloudOutput) ToGetStackBitbucketCloudOutput() GetStackBitbucketCloudOutput { + return o +} + +func (o GetStackBitbucketCloudOutput) ToGetStackBitbucketCloudOutputWithContext(ctx context.Context) GetStackBitbucketCloudOutput { + return o +} + +func (o GetStackBitbucketCloudOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackBitbucketCloud] { + return pulumix.Output[GetStackBitbucketCloud]{ + OutputState: o.OutputState, + } +} + +func (o GetStackBitbucketCloudOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStackBitbucketCloud) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetStackBitbucketCloudArrayOutput struct{ *pulumi.OutputState } + +func (GetStackBitbucketCloudArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackBitbucketCloud)(nil)).Elem() +} + +func (o GetStackBitbucketCloudArrayOutput) ToGetStackBitbucketCloudArrayOutput() GetStackBitbucketCloudArrayOutput { + return o +} + +func (o GetStackBitbucketCloudArrayOutput) ToGetStackBitbucketCloudArrayOutputWithContext(ctx context.Context) GetStackBitbucketCloudArrayOutput { + return o +} + +func (o GetStackBitbucketCloudArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackBitbucketCloud] { + return pulumix.Output[[]GetStackBitbucketCloud]{ + OutputState: o.OutputState, + } +} + +func (o GetStackBitbucketCloudArrayOutput) Index(i pulumi.IntInput) GetStackBitbucketCloudOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackBitbucketCloud { + return vs[0].([]GetStackBitbucketCloud)[vs[1].(int)] + }).(GetStackBitbucketCloudOutput) +} + +type GetStackBitbucketDatacenter struct { + Namespace string `pulumi:"namespace"` +} + +// GetStackBitbucketDatacenterInput is an input type that accepts GetStackBitbucketDatacenterArgs and GetStackBitbucketDatacenterOutput values. +// You can construct a concrete instance of `GetStackBitbucketDatacenterInput` via: +// +// GetStackBitbucketDatacenterArgs{...} +type GetStackBitbucketDatacenterInput interface { + pulumi.Input + + ToGetStackBitbucketDatacenterOutput() GetStackBitbucketDatacenterOutput + ToGetStackBitbucketDatacenterOutputWithContext(context.Context) GetStackBitbucketDatacenterOutput +} + +type GetStackBitbucketDatacenterArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetStackBitbucketDatacenterArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackBitbucketDatacenter)(nil)).Elem() +} + +func (i GetStackBitbucketDatacenterArgs) ToGetStackBitbucketDatacenterOutput() GetStackBitbucketDatacenterOutput { + return i.ToGetStackBitbucketDatacenterOutputWithContext(context.Background()) +} + +func (i GetStackBitbucketDatacenterArgs) ToGetStackBitbucketDatacenterOutputWithContext(ctx context.Context) GetStackBitbucketDatacenterOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackBitbucketDatacenterOutput) +} + +func (i GetStackBitbucketDatacenterArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackBitbucketDatacenter] { + return pulumix.Output[GetStackBitbucketDatacenter]{ + OutputState: i.ToGetStackBitbucketDatacenterOutputWithContext(ctx).OutputState, + } +} + +// GetStackBitbucketDatacenterArrayInput is an input type that accepts GetStackBitbucketDatacenterArray and GetStackBitbucketDatacenterArrayOutput values. +// You can construct a concrete instance of `GetStackBitbucketDatacenterArrayInput` via: +// +// GetStackBitbucketDatacenterArray{ GetStackBitbucketDatacenterArgs{...} } +type GetStackBitbucketDatacenterArrayInput interface { + pulumi.Input + + ToGetStackBitbucketDatacenterArrayOutput() GetStackBitbucketDatacenterArrayOutput + ToGetStackBitbucketDatacenterArrayOutputWithContext(context.Context) GetStackBitbucketDatacenterArrayOutput +} + +type GetStackBitbucketDatacenterArray []GetStackBitbucketDatacenterInput + +func (GetStackBitbucketDatacenterArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackBitbucketDatacenter)(nil)).Elem() +} + +func (i GetStackBitbucketDatacenterArray) ToGetStackBitbucketDatacenterArrayOutput() GetStackBitbucketDatacenterArrayOutput { + return i.ToGetStackBitbucketDatacenterArrayOutputWithContext(context.Background()) +} + +func (i GetStackBitbucketDatacenterArray) ToGetStackBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetStackBitbucketDatacenterArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackBitbucketDatacenterArrayOutput) +} + +func (i GetStackBitbucketDatacenterArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackBitbucketDatacenter] { + return pulumix.Output[[]GetStackBitbucketDatacenter]{ + OutputState: i.ToGetStackBitbucketDatacenterArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackBitbucketDatacenterOutput struct{ *pulumi.OutputState } + +func (GetStackBitbucketDatacenterOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackBitbucketDatacenter)(nil)).Elem() +} + +func (o GetStackBitbucketDatacenterOutput) ToGetStackBitbucketDatacenterOutput() GetStackBitbucketDatacenterOutput { + return o +} + +func (o GetStackBitbucketDatacenterOutput) ToGetStackBitbucketDatacenterOutputWithContext(ctx context.Context) GetStackBitbucketDatacenterOutput { + return o +} + +func (o GetStackBitbucketDatacenterOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackBitbucketDatacenter] { + return pulumix.Output[GetStackBitbucketDatacenter]{ + OutputState: o.OutputState, + } +} + +func (o GetStackBitbucketDatacenterOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStackBitbucketDatacenter) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetStackBitbucketDatacenterArrayOutput struct{ *pulumi.OutputState } + +func (GetStackBitbucketDatacenterArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackBitbucketDatacenter)(nil)).Elem() +} + +func (o GetStackBitbucketDatacenterArrayOutput) ToGetStackBitbucketDatacenterArrayOutput() GetStackBitbucketDatacenterArrayOutput { + return o +} + +func (o GetStackBitbucketDatacenterArrayOutput) ToGetStackBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetStackBitbucketDatacenterArrayOutput { + return o +} + +func (o GetStackBitbucketDatacenterArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackBitbucketDatacenter] { + return pulumix.Output[[]GetStackBitbucketDatacenter]{ + OutputState: o.OutputState, + } +} + +func (o GetStackBitbucketDatacenterArrayOutput) Index(i pulumi.IntInput) GetStackBitbucketDatacenterOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackBitbucketDatacenter { + return vs[0].([]GetStackBitbucketDatacenter)[vs[1].(int)] + }).(GetStackBitbucketDatacenterOutput) +} + +type GetStackCloudformation struct { + EntryTemplateFile string `pulumi:"entryTemplateFile"` + Region string `pulumi:"region"` + StackName string `pulumi:"stackName"` + TemplateBucket string `pulumi:"templateBucket"` +} + +// GetStackCloudformationInput is an input type that accepts GetStackCloudformationArgs and GetStackCloudformationOutput values. +// You can construct a concrete instance of `GetStackCloudformationInput` via: +// +// GetStackCloudformationArgs{...} +type GetStackCloudformationInput interface { + pulumi.Input + + ToGetStackCloudformationOutput() GetStackCloudformationOutput + ToGetStackCloudformationOutputWithContext(context.Context) GetStackCloudformationOutput +} + +type GetStackCloudformationArgs struct { + EntryTemplateFile pulumi.StringInput `pulumi:"entryTemplateFile"` + Region pulumi.StringInput `pulumi:"region"` + StackName pulumi.StringInput `pulumi:"stackName"` + TemplateBucket pulumi.StringInput `pulumi:"templateBucket"` +} + +func (GetStackCloudformationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackCloudformation)(nil)).Elem() +} + +func (i GetStackCloudformationArgs) ToGetStackCloudformationOutput() GetStackCloudformationOutput { + return i.ToGetStackCloudformationOutputWithContext(context.Background()) +} + +func (i GetStackCloudformationArgs) ToGetStackCloudformationOutputWithContext(ctx context.Context) GetStackCloudformationOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackCloudformationOutput) +} + +func (i GetStackCloudformationArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackCloudformation] { + return pulumix.Output[GetStackCloudformation]{ + OutputState: i.ToGetStackCloudformationOutputWithContext(ctx).OutputState, + } +} + +// GetStackCloudformationArrayInput is an input type that accepts GetStackCloudformationArray and GetStackCloudformationArrayOutput values. +// You can construct a concrete instance of `GetStackCloudformationArrayInput` via: +// +// GetStackCloudformationArray{ GetStackCloudformationArgs{...} } +type GetStackCloudformationArrayInput interface { + pulumi.Input + + ToGetStackCloudformationArrayOutput() GetStackCloudformationArrayOutput + ToGetStackCloudformationArrayOutputWithContext(context.Context) GetStackCloudformationArrayOutput +} + +type GetStackCloudformationArray []GetStackCloudformationInput + +func (GetStackCloudformationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackCloudformation)(nil)).Elem() +} + +func (i GetStackCloudformationArray) ToGetStackCloudformationArrayOutput() GetStackCloudformationArrayOutput { + return i.ToGetStackCloudformationArrayOutputWithContext(context.Background()) +} + +func (i GetStackCloudformationArray) ToGetStackCloudformationArrayOutputWithContext(ctx context.Context) GetStackCloudformationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackCloudformationArrayOutput) +} + +func (i GetStackCloudformationArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackCloudformation] { + return pulumix.Output[[]GetStackCloudformation]{ + OutputState: i.ToGetStackCloudformationArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackCloudformationOutput struct{ *pulumi.OutputState } + +func (GetStackCloudformationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackCloudformation)(nil)).Elem() +} + +func (o GetStackCloudformationOutput) ToGetStackCloudformationOutput() GetStackCloudformationOutput { + return o +} + +func (o GetStackCloudformationOutput) ToGetStackCloudformationOutputWithContext(ctx context.Context) GetStackCloudformationOutput { + return o +} + +func (o GetStackCloudformationOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackCloudformation] { + return pulumix.Output[GetStackCloudformation]{ + OutputState: o.OutputState, + } +} + +func (o GetStackCloudformationOutput) EntryTemplateFile() pulumi.StringOutput { + return o.ApplyT(func(v GetStackCloudformation) string { return v.EntryTemplateFile }).(pulumi.StringOutput) +} + +func (o GetStackCloudformationOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v GetStackCloudformation) string { return v.Region }).(pulumi.StringOutput) +} + +func (o GetStackCloudformationOutput) StackName() pulumi.StringOutput { + return o.ApplyT(func(v GetStackCloudformation) string { return v.StackName }).(pulumi.StringOutput) +} + +func (o GetStackCloudformationOutput) TemplateBucket() pulumi.StringOutput { + return o.ApplyT(func(v GetStackCloudformation) string { return v.TemplateBucket }).(pulumi.StringOutput) +} + +type GetStackCloudformationArrayOutput struct{ *pulumi.OutputState } + +func (GetStackCloudformationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackCloudformation)(nil)).Elem() +} + +func (o GetStackCloudformationArrayOutput) ToGetStackCloudformationArrayOutput() GetStackCloudformationArrayOutput { + return o +} + +func (o GetStackCloudformationArrayOutput) ToGetStackCloudformationArrayOutputWithContext(ctx context.Context) GetStackCloudformationArrayOutput { + return o +} + +func (o GetStackCloudformationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackCloudformation] { + return pulumix.Output[[]GetStackCloudformation]{ + OutputState: o.OutputState, + } +} + +func (o GetStackCloudformationArrayOutput) Index(i pulumi.IntInput) GetStackCloudformationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackCloudformation { + return vs[0].([]GetStackCloudformation)[vs[1].(int)] + }).(GetStackCloudformationOutput) +} + +type GetStackGithubEnterprise struct { + Namespace string `pulumi:"namespace"` +} + +// GetStackGithubEnterpriseInput is an input type that accepts GetStackGithubEnterpriseArgs and GetStackGithubEnterpriseOutput values. +// You can construct a concrete instance of `GetStackGithubEnterpriseInput` via: +// +// GetStackGithubEnterpriseArgs{...} +type GetStackGithubEnterpriseInput interface { + pulumi.Input + + ToGetStackGithubEnterpriseOutput() GetStackGithubEnterpriseOutput + ToGetStackGithubEnterpriseOutputWithContext(context.Context) GetStackGithubEnterpriseOutput +} + +type GetStackGithubEnterpriseArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetStackGithubEnterpriseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackGithubEnterprise)(nil)).Elem() +} + +func (i GetStackGithubEnterpriseArgs) ToGetStackGithubEnterpriseOutput() GetStackGithubEnterpriseOutput { + return i.ToGetStackGithubEnterpriseOutputWithContext(context.Background()) +} + +func (i GetStackGithubEnterpriseArgs) ToGetStackGithubEnterpriseOutputWithContext(ctx context.Context) GetStackGithubEnterpriseOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackGithubEnterpriseOutput) +} + +func (i GetStackGithubEnterpriseArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackGithubEnterprise] { + return pulumix.Output[GetStackGithubEnterprise]{ + OutputState: i.ToGetStackGithubEnterpriseOutputWithContext(ctx).OutputState, + } +} + +// GetStackGithubEnterpriseArrayInput is an input type that accepts GetStackGithubEnterpriseArray and GetStackGithubEnterpriseArrayOutput values. +// You can construct a concrete instance of `GetStackGithubEnterpriseArrayInput` via: +// +// GetStackGithubEnterpriseArray{ GetStackGithubEnterpriseArgs{...} } +type GetStackGithubEnterpriseArrayInput interface { + pulumi.Input + + ToGetStackGithubEnterpriseArrayOutput() GetStackGithubEnterpriseArrayOutput + ToGetStackGithubEnterpriseArrayOutputWithContext(context.Context) GetStackGithubEnterpriseArrayOutput +} + +type GetStackGithubEnterpriseArray []GetStackGithubEnterpriseInput + +func (GetStackGithubEnterpriseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackGithubEnterprise)(nil)).Elem() +} + +func (i GetStackGithubEnterpriseArray) ToGetStackGithubEnterpriseArrayOutput() GetStackGithubEnterpriseArrayOutput { + return i.ToGetStackGithubEnterpriseArrayOutputWithContext(context.Background()) +} + +func (i GetStackGithubEnterpriseArray) ToGetStackGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetStackGithubEnterpriseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackGithubEnterpriseArrayOutput) +} + +func (i GetStackGithubEnterpriseArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackGithubEnterprise] { + return pulumix.Output[[]GetStackGithubEnterprise]{ + OutputState: i.ToGetStackGithubEnterpriseArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackGithubEnterpriseOutput struct{ *pulumi.OutputState } + +func (GetStackGithubEnterpriseOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackGithubEnterprise)(nil)).Elem() +} + +func (o GetStackGithubEnterpriseOutput) ToGetStackGithubEnterpriseOutput() GetStackGithubEnterpriseOutput { + return o +} + +func (o GetStackGithubEnterpriseOutput) ToGetStackGithubEnterpriseOutputWithContext(ctx context.Context) GetStackGithubEnterpriseOutput { + return o +} + +func (o GetStackGithubEnterpriseOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackGithubEnterprise] { + return pulumix.Output[GetStackGithubEnterprise]{ + OutputState: o.OutputState, + } +} + +func (o GetStackGithubEnterpriseOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStackGithubEnterprise) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetStackGithubEnterpriseArrayOutput struct{ *pulumi.OutputState } + +func (GetStackGithubEnterpriseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackGithubEnterprise)(nil)).Elem() +} + +func (o GetStackGithubEnterpriseArrayOutput) ToGetStackGithubEnterpriseArrayOutput() GetStackGithubEnterpriseArrayOutput { + return o +} + +func (o GetStackGithubEnterpriseArrayOutput) ToGetStackGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetStackGithubEnterpriseArrayOutput { + return o +} + +func (o GetStackGithubEnterpriseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackGithubEnterprise] { + return pulumix.Output[[]GetStackGithubEnterprise]{ + OutputState: o.OutputState, + } +} + +func (o GetStackGithubEnterpriseArrayOutput) Index(i pulumi.IntInput) GetStackGithubEnterpriseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackGithubEnterprise { + return vs[0].([]GetStackGithubEnterprise)[vs[1].(int)] + }).(GetStackGithubEnterpriseOutput) +} + +type GetStackGitlab struct { + Namespace string `pulumi:"namespace"` +} + +// GetStackGitlabInput is an input type that accepts GetStackGitlabArgs and GetStackGitlabOutput values. +// You can construct a concrete instance of `GetStackGitlabInput` via: +// +// GetStackGitlabArgs{...} +type GetStackGitlabInput interface { + pulumi.Input + + ToGetStackGitlabOutput() GetStackGitlabOutput + ToGetStackGitlabOutputWithContext(context.Context) GetStackGitlabOutput +} + +type GetStackGitlabArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetStackGitlabArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackGitlab)(nil)).Elem() +} + +func (i GetStackGitlabArgs) ToGetStackGitlabOutput() GetStackGitlabOutput { + return i.ToGetStackGitlabOutputWithContext(context.Background()) +} + +func (i GetStackGitlabArgs) ToGetStackGitlabOutputWithContext(ctx context.Context) GetStackGitlabOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackGitlabOutput) +} + +func (i GetStackGitlabArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackGitlab] { + return pulumix.Output[GetStackGitlab]{ + OutputState: i.ToGetStackGitlabOutputWithContext(ctx).OutputState, + } +} + +// GetStackGitlabArrayInput is an input type that accepts GetStackGitlabArray and GetStackGitlabArrayOutput values. +// You can construct a concrete instance of `GetStackGitlabArrayInput` via: +// +// GetStackGitlabArray{ GetStackGitlabArgs{...} } +type GetStackGitlabArrayInput interface { + pulumi.Input + + ToGetStackGitlabArrayOutput() GetStackGitlabArrayOutput + ToGetStackGitlabArrayOutputWithContext(context.Context) GetStackGitlabArrayOutput +} + +type GetStackGitlabArray []GetStackGitlabInput + +func (GetStackGitlabArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackGitlab)(nil)).Elem() +} + +func (i GetStackGitlabArray) ToGetStackGitlabArrayOutput() GetStackGitlabArrayOutput { + return i.ToGetStackGitlabArrayOutputWithContext(context.Background()) +} + +func (i GetStackGitlabArray) ToGetStackGitlabArrayOutputWithContext(ctx context.Context) GetStackGitlabArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackGitlabArrayOutput) +} + +func (i GetStackGitlabArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackGitlab] { + return pulumix.Output[[]GetStackGitlab]{ + OutputState: i.ToGetStackGitlabArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackGitlabOutput struct{ *pulumi.OutputState } + +func (GetStackGitlabOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackGitlab)(nil)).Elem() +} + +func (o GetStackGitlabOutput) ToGetStackGitlabOutput() GetStackGitlabOutput { + return o +} + +func (o GetStackGitlabOutput) ToGetStackGitlabOutputWithContext(ctx context.Context) GetStackGitlabOutput { + return o +} + +func (o GetStackGitlabOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackGitlab] { + return pulumix.Output[GetStackGitlab]{ + OutputState: o.OutputState, + } +} + +func (o GetStackGitlabOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStackGitlab) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetStackGitlabArrayOutput struct{ *pulumi.OutputState } + +func (GetStackGitlabArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackGitlab)(nil)).Elem() +} + +func (o GetStackGitlabArrayOutput) ToGetStackGitlabArrayOutput() GetStackGitlabArrayOutput { + return o +} + +func (o GetStackGitlabArrayOutput) ToGetStackGitlabArrayOutputWithContext(ctx context.Context) GetStackGitlabArrayOutput { + return o +} + +func (o GetStackGitlabArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackGitlab] { + return pulumix.Output[[]GetStackGitlab]{ + OutputState: o.OutputState, + } +} + +func (o GetStackGitlabArrayOutput) Index(i pulumi.IntInput) GetStackGitlabOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackGitlab { + return vs[0].([]GetStackGitlab)[vs[1].(int)] + }).(GetStackGitlabOutput) +} + +type GetStackKubernete struct { + KubectlVersion string `pulumi:"kubectlVersion"` + Namespace string `pulumi:"namespace"` +} + +// GetStackKuberneteInput is an input type that accepts GetStackKuberneteArgs and GetStackKuberneteOutput values. +// You can construct a concrete instance of `GetStackKuberneteInput` via: +// +// GetStackKuberneteArgs{...} +type GetStackKuberneteInput interface { + pulumi.Input + + ToGetStackKuberneteOutput() GetStackKuberneteOutput + ToGetStackKuberneteOutputWithContext(context.Context) GetStackKuberneteOutput +} + +type GetStackKuberneteArgs struct { + KubectlVersion pulumi.StringInput `pulumi:"kubectlVersion"` + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetStackKuberneteArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackKubernete)(nil)).Elem() +} + +func (i GetStackKuberneteArgs) ToGetStackKuberneteOutput() GetStackKuberneteOutput { + return i.ToGetStackKuberneteOutputWithContext(context.Background()) +} + +func (i GetStackKuberneteArgs) ToGetStackKuberneteOutputWithContext(ctx context.Context) GetStackKuberneteOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackKuberneteOutput) +} + +func (i GetStackKuberneteArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackKubernete] { + return pulumix.Output[GetStackKubernete]{ + OutputState: i.ToGetStackKuberneteOutputWithContext(ctx).OutputState, + } +} + +// GetStackKuberneteArrayInput is an input type that accepts GetStackKuberneteArray and GetStackKuberneteArrayOutput values. +// You can construct a concrete instance of `GetStackKuberneteArrayInput` via: +// +// GetStackKuberneteArray{ GetStackKuberneteArgs{...} } +type GetStackKuberneteArrayInput interface { + pulumi.Input + + ToGetStackKuberneteArrayOutput() GetStackKuberneteArrayOutput + ToGetStackKuberneteArrayOutputWithContext(context.Context) GetStackKuberneteArrayOutput +} + +type GetStackKuberneteArray []GetStackKuberneteInput + +func (GetStackKuberneteArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackKubernete)(nil)).Elem() +} + +func (i GetStackKuberneteArray) ToGetStackKuberneteArrayOutput() GetStackKuberneteArrayOutput { + return i.ToGetStackKuberneteArrayOutputWithContext(context.Background()) +} + +func (i GetStackKuberneteArray) ToGetStackKuberneteArrayOutputWithContext(ctx context.Context) GetStackKuberneteArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackKuberneteArrayOutput) +} + +func (i GetStackKuberneteArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackKubernete] { + return pulumix.Output[[]GetStackKubernete]{ + OutputState: i.ToGetStackKuberneteArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackKuberneteOutput struct{ *pulumi.OutputState } + +func (GetStackKuberneteOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackKubernete)(nil)).Elem() +} + +func (o GetStackKuberneteOutput) ToGetStackKuberneteOutput() GetStackKuberneteOutput { + return o +} + +func (o GetStackKuberneteOutput) ToGetStackKuberneteOutputWithContext(ctx context.Context) GetStackKuberneteOutput { + return o +} + +func (o GetStackKuberneteOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackKubernete] { + return pulumix.Output[GetStackKubernete]{ + OutputState: o.OutputState, + } +} + +func (o GetStackKuberneteOutput) KubectlVersion() pulumi.StringOutput { + return o.ApplyT(func(v GetStackKubernete) string { return v.KubectlVersion }).(pulumi.StringOutput) +} + +func (o GetStackKuberneteOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStackKubernete) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetStackKuberneteArrayOutput struct{ *pulumi.OutputState } + +func (GetStackKuberneteArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackKubernete)(nil)).Elem() +} + +func (o GetStackKuberneteArrayOutput) ToGetStackKuberneteArrayOutput() GetStackKuberneteArrayOutput { + return o +} + +func (o GetStackKuberneteArrayOutput) ToGetStackKuberneteArrayOutputWithContext(ctx context.Context) GetStackKuberneteArrayOutput { + return o +} + +func (o GetStackKuberneteArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackKubernete] { + return pulumix.Output[[]GetStackKubernete]{ + OutputState: o.OutputState, + } +} + +func (o GetStackKuberneteArrayOutput) Index(i pulumi.IntInput) GetStackKuberneteOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackKubernete { + return vs[0].([]GetStackKubernete)[vs[1].(int)] + }).(GetStackKuberneteOutput) +} + +type GetStackPulumi struct { + LoginUrl string `pulumi:"loginUrl"` + StackName string `pulumi:"stackName"` +} + +// GetStackPulumiInput is an input type that accepts GetStackPulumiArgs and GetStackPulumiOutput values. +// You can construct a concrete instance of `GetStackPulumiInput` via: +// +// GetStackPulumiArgs{...} +type GetStackPulumiInput interface { + pulumi.Input + + ToGetStackPulumiOutput() GetStackPulumiOutput + ToGetStackPulumiOutputWithContext(context.Context) GetStackPulumiOutput +} + +type GetStackPulumiArgs struct { + LoginUrl pulumi.StringInput `pulumi:"loginUrl"` + StackName pulumi.StringInput `pulumi:"stackName"` +} + +func (GetStackPulumiArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackPulumi)(nil)).Elem() +} + +func (i GetStackPulumiArgs) ToGetStackPulumiOutput() GetStackPulumiOutput { + return i.ToGetStackPulumiOutputWithContext(context.Background()) +} + +func (i GetStackPulumiArgs) ToGetStackPulumiOutputWithContext(ctx context.Context) GetStackPulumiOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackPulumiOutput) +} + +func (i GetStackPulumiArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackPulumi] { + return pulumix.Output[GetStackPulumi]{ + OutputState: i.ToGetStackPulumiOutputWithContext(ctx).OutputState, + } +} + +// GetStackPulumiArrayInput is an input type that accepts GetStackPulumiArray and GetStackPulumiArrayOutput values. +// You can construct a concrete instance of `GetStackPulumiArrayInput` via: +// +// GetStackPulumiArray{ GetStackPulumiArgs{...} } +type GetStackPulumiArrayInput interface { + pulumi.Input + + ToGetStackPulumiArrayOutput() GetStackPulumiArrayOutput + ToGetStackPulumiArrayOutputWithContext(context.Context) GetStackPulumiArrayOutput +} + +type GetStackPulumiArray []GetStackPulumiInput + +func (GetStackPulumiArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackPulumi)(nil)).Elem() +} + +func (i GetStackPulumiArray) ToGetStackPulumiArrayOutput() GetStackPulumiArrayOutput { + return i.ToGetStackPulumiArrayOutputWithContext(context.Background()) +} + +func (i GetStackPulumiArray) ToGetStackPulumiArrayOutputWithContext(ctx context.Context) GetStackPulumiArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackPulumiArrayOutput) +} + +func (i GetStackPulumiArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackPulumi] { + return pulumix.Output[[]GetStackPulumi]{ + OutputState: i.ToGetStackPulumiArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackPulumiOutput struct{ *pulumi.OutputState } + +func (GetStackPulumiOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackPulumi)(nil)).Elem() +} + +func (o GetStackPulumiOutput) ToGetStackPulumiOutput() GetStackPulumiOutput { + return o +} + +func (o GetStackPulumiOutput) ToGetStackPulumiOutputWithContext(ctx context.Context) GetStackPulumiOutput { + return o +} + +func (o GetStackPulumiOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackPulumi] { + return pulumix.Output[GetStackPulumi]{ + OutputState: o.OutputState, + } +} + +func (o GetStackPulumiOutput) LoginUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetStackPulumi) string { return v.LoginUrl }).(pulumi.StringOutput) +} + +func (o GetStackPulumiOutput) StackName() pulumi.StringOutput { + return o.ApplyT(func(v GetStackPulumi) string { return v.StackName }).(pulumi.StringOutput) +} + +type GetStackPulumiArrayOutput struct{ *pulumi.OutputState } + +func (GetStackPulumiArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackPulumi)(nil)).Elem() +} + +func (o GetStackPulumiArrayOutput) ToGetStackPulumiArrayOutput() GetStackPulumiArrayOutput { + return o +} + +func (o GetStackPulumiArrayOutput) ToGetStackPulumiArrayOutputWithContext(ctx context.Context) GetStackPulumiArrayOutput { + return o +} + +func (o GetStackPulumiArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackPulumi] { + return pulumix.Output[[]GetStackPulumi]{ + OutputState: o.OutputState, + } +} + +func (o GetStackPulumiArrayOutput) Index(i pulumi.IntInput) GetStackPulumiOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackPulumi { + return vs[0].([]GetStackPulumi)[vs[1].(int)] + }).(GetStackPulumiOutput) +} + +type GetStackRawGit struct { + Namespace string `pulumi:"namespace"` + Url string `pulumi:"url"` +} + +// GetStackRawGitInput is an input type that accepts GetStackRawGitArgs and GetStackRawGitOutput values. +// You can construct a concrete instance of `GetStackRawGitInput` via: +// +// GetStackRawGitArgs{...} +type GetStackRawGitInput interface { + pulumi.Input + + ToGetStackRawGitOutput() GetStackRawGitOutput + ToGetStackRawGitOutputWithContext(context.Context) GetStackRawGitOutput +} + +type GetStackRawGitArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetStackRawGitArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackRawGit)(nil)).Elem() +} + +func (i GetStackRawGitArgs) ToGetStackRawGitOutput() GetStackRawGitOutput { + return i.ToGetStackRawGitOutputWithContext(context.Background()) +} + +func (i GetStackRawGitArgs) ToGetStackRawGitOutputWithContext(ctx context.Context) GetStackRawGitOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackRawGitOutput) +} + +func (i GetStackRawGitArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackRawGit] { + return pulumix.Output[GetStackRawGit]{ + OutputState: i.ToGetStackRawGitOutputWithContext(ctx).OutputState, + } +} + +// GetStackRawGitArrayInput is an input type that accepts GetStackRawGitArray and GetStackRawGitArrayOutput values. +// You can construct a concrete instance of `GetStackRawGitArrayInput` via: +// +// GetStackRawGitArray{ GetStackRawGitArgs{...} } +type GetStackRawGitArrayInput interface { + pulumi.Input + + ToGetStackRawGitArrayOutput() GetStackRawGitArrayOutput + ToGetStackRawGitArrayOutputWithContext(context.Context) GetStackRawGitArrayOutput +} + +type GetStackRawGitArray []GetStackRawGitInput + +func (GetStackRawGitArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackRawGit)(nil)).Elem() +} + +func (i GetStackRawGitArray) ToGetStackRawGitArrayOutput() GetStackRawGitArrayOutput { + return i.ToGetStackRawGitArrayOutputWithContext(context.Background()) +} + +func (i GetStackRawGitArray) ToGetStackRawGitArrayOutputWithContext(ctx context.Context) GetStackRawGitArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackRawGitArrayOutput) +} + +func (i GetStackRawGitArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackRawGit] { + return pulumix.Output[[]GetStackRawGit]{ + OutputState: i.ToGetStackRawGitArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackRawGitOutput struct{ *pulumi.OutputState } + +func (GetStackRawGitOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackRawGit)(nil)).Elem() +} + +func (o GetStackRawGitOutput) ToGetStackRawGitOutput() GetStackRawGitOutput { + return o +} + +func (o GetStackRawGitOutput) ToGetStackRawGitOutputWithContext(ctx context.Context) GetStackRawGitOutput { + return o +} + +func (o GetStackRawGitOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackRawGit] { + return pulumix.Output[GetStackRawGit]{ + OutputState: o.OutputState, + } +} + +func (o GetStackRawGitOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStackRawGit) string { return v.Namespace }).(pulumi.StringOutput) +} + +func (o GetStackRawGitOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetStackRawGit) string { return v.Url }).(pulumi.StringOutput) +} + +type GetStackRawGitArrayOutput struct{ *pulumi.OutputState } + +func (GetStackRawGitArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackRawGit)(nil)).Elem() +} + +func (o GetStackRawGitArrayOutput) ToGetStackRawGitArrayOutput() GetStackRawGitArrayOutput { + return o +} + +func (o GetStackRawGitArrayOutput) ToGetStackRawGitArrayOutputWithContext(ctx context.Context) GetStackRawGitArrayOutput { + return o +} + +func (o GetStackRawGitArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackRawGit] { + return pulumix.Output[[]GetStackRawGit]{ + OutputState: o.OutputState, + } +} + +func (o GetStackRawGitArrayOutput) Index(i pulumi.IntInput) GetStackRawGitOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackRawGit { + return vs[0].([]GetStackRawGit)[vs[1].(int)] + }).(GetStackRawGitOutput) +} + +type GetStackShowcase struct { + Namespace string `pulumi:"namespace"` +} + +// GetStackShowcaseInput is an input type that accepts GetStackShowcaseArgs and GetStackShowcaseOutput values. +// You can construct a concrete instance of `GetStackShowcaseInput` via: +// +// GetStackShowcaseArgs{...} +type GetStackShowcaseInput interface { + pulumi.Input + + ToGetStackShowcaseOutput() GetStackShowcaseOutput + ToGetStackShowcaseOutputWithContext(context.Context) GetStackShowcaseOutput +} + +type GetStackShowcaseArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` +} + +func (GetStackShowcaseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackShowcase)(nil)).Elem() +} + +func (i GetStackShowcaseArgs) ToGetStackShowcaseOutput() GetStackShowcaseOutput { + return i.ToGetStackShowcaseOutputWithContext(context.Background()) +} + +func (i GetStackShowcaseArgs) ToGetStackShowcaseOutputWithContext(ctx context.Context) GetStackShowcaseOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackShowcaseOutput) +} + +func (i GetStackShowcaseArgs) ToOutput(ctx context.Context) pulumix.Output[GetStackShowcase] { + return pulumix.Output[GetStackShowcase]{ + OutputState: i.ToGetStackShowcaseOutputWithContext(ctx).OutputState, + } +} + +// GetStackShowcaseArrayInput is an input type that accepts GetStackShowcaseArray and GetStackShowcaseArrayOutput values. +// You can construct a concrete instance of `GetStackShowcaseArrayInput` via: +// +// GetStackShowcaseArray{ GetStackShowcaseArgs{...} } +type GetStackShowcaseArrayInput interface { + pulumi.Input + + ToGetStackShowcaseArrayOutput() GetStackShowcaseArrayOutput + ToGetStackShowcaseArrayOutputWithContext(context.Context) GetStackShowcaseArrayOutput +} + +type GetStackShowcaseArray []GetStackShowcaseInput + +func (GetStackShowcaseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackShowcase)(nil)).Elem() +} + +func (i GetStackShowcaseArray) ToGetStackShowcaseArrayOutput() GetStackShowcaseArrayOutput { + return i.ToGetStackShowcaseArrayOutputWithContext(context.Background()) +} + +func (i GetStackShowcaseArray) ToGetStackShowcaseArrayOutputWithContext(ctx context.Context) GetStackShowcaseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStackShowcaseArrayOutput) +} + +func (i GetStackShowcaseArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStackShowcase] { + return pulumix.Output[[]GetStackShowcase]{ + OutputState: i.ToGetStackShowcaseArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStackShowcaseOutput struct{ *pulumi.OutputState } + +func (GetStackShowcaseOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStackShowcase)(nil)).Elem() +} + +func (o GetStackShowcaseOutput) ToGetStackShowcaseOutput() GetStackShowcaseOutput { + return o +} + +func (o GetStackShowcaseOutput) ToGetStackShowcaseOutputWithContext(ctx context.Context) GetStackShowcaseOutput { + return o +} + +func (o GetStackShowcaseOutput) ToOutput(ctx context.Context) pulumix.Output[GetStackShowcase] { + return pulumix.Output[GetStackShowcase]{ + OutputState: o.OutputState, + } +} + +func (o GetStackShowcaseOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStackShowcase) string { return v.Namespace }).(pulumi.StringOutput) +} + +type GetStackShowcaseArrayOutput struct{ *pulumi.OutputState } + +func (GetStackShowcaseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStackShowcase)(nil)).Elem() +} + +func (o GetStackShowcaseArrayOutput) ToGetStackShowcaseArrayOutput() GetStackShowcaseArrayOutput { + return o +} + +func (o GetStackShowcaseArrayOutput) ToGetStackShowcaseArrayOutputWithContext(ctx context.Context) GetStackShowcaseArrayOutput { + return o +} + +func (o GetStackShowcaseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStackShowcase] { + return pulumix.Output[[]GetStackShowcase]{ + OutputState: o.OutputState, + } +} + +func (o GetStackShowcaseArrayOutput) Index(i pulumi.IntInput) GetStackShowcaseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackShowcase { + return vs[0].([]GetStackShowcase)[vs[1].(int)] + }).(GetStackShowcaseOutput) +} + +type GetStacksAdministrative struct { + Equals *bool `pulumi:"equals"` +} + +// GetStacksAdministrativeInput is an input type that accepts GetStacksAdministrativeArgs and GetStacksAdministrativeOutput values. +// You can construct a concrete instance of `GetStacksAdministrativeInput` via: +// +// GetStacksAdministrativeArgs{...} +type GetStacksAdministrativeInput interface { + pulumi.Input + + ToGetStacksAdministrativeOutput() GetStacksAdministrativeOutput + ToGetStacksAdministrativeOutputWithContext(context.Context) GetStacksAdministrativeOutput +} + +type GetStacksAdministrativeArgs struct { + Equals pulumi.BoolPtrInput `pulumi:"equals"` +} + +func (GetStacksAdministrativeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksAdministrative)(nil)).Elem() +} + +func (i GetStacksAdministrativeArgs) ToGetStacksAdministrativeOutput() GetStacksAdministrativeOutput { + return i.ToGetStacksAdministrativeOutputWithContext(context.Background()) +} + +func (i GetStacksAdministrativeArgs) ToGetStacksAdministrativeOutputWithContext(ctx context.Context) GetStacksAdministrativeOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksAdministrativeOutput) +} + +func (i GetStacksAdministrativeArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksAdministrative] { + return pulumix.Output[GetStacksAdministrative]{ + OutputState: i.ToGetStacksAdministrativeOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksAdministrativeArgs) ToGetStacksAdministrativePtrOutput() GetStacksAdministrativePtrOutput { + return i.ToGetStacksAdministrativePtrOutputWithContext(context.Background()) +} + +func (i GetStacksAdministrativeArgs) ToGetStacksAdministrativePtrOutputWithContext(ctx context.Context) GetStacksAdministrativePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksAdministrativeOutput).ToGetStacksAdministrativePtrOutputWithContext(ctx) +} + +// GetStacksAdministrativePtrInput is an input type that accepts GetStacksAdministrativeArgs, GetStacksAdministrativePtr and GetStacksAdministrativePtrOutput values. +// You can construct a concrete instance of `GetStacksAdministrativePtrInput` via: +// +// GetStacksAdministrativeArgs{...} +// +// or: +// +// nil +type GetStacksAdministrativePtrInput interface { + pulumi.Input + + ToGetStacksAdministrativePtrOutput() GetStacksAdministrativePtrOutput + ToGetStacksAdministrativePtrOutputWithContext(context.Context) GetStacksAdministrativePtrOutput +} + +type getStacksAdministrativePtrType GetStacksAdministrativeArgs + +func GetStacksAdministrativePtr(v *GetStacksAdministrativeArgs) GetStacksAdministrativePtrInput { + return (*getStacksAdministrativePtrType)(v) +} + +func (*getStacksAdministrativePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksAdministrative)(nil)).Elem() +} + +func (i *getStacksAdministrativePtrType) ToGetStacksAdministrativePtrOutput() GetStacksAdministrativePtrOutput { + return i.ToGetStacksAdministrativePtrOutputWithContext(context.Background()) +} + +func (i *getStacksAdministrativePtrType) ToGetStacksAdministrativePtrOutputWithContext(ctx context.Context) GetStacksAdministrativePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksAdministrativePtrOutput) +} + +func (i *getStacksAdministrativePtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksAdministrative] { + return pulumix.Output[*GetStacksAdministrative]{ + OutputState: i.ToGetStacksAdministrativePtrOutputWithContext(ctx).OutputState, + } +} + +type GetStacksAdministrativeOutput struct{ *pulumi.OutputState } + +func (GetStacksAdministrativeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksAdministrative)(nil)).Elem() +} + +func (o GetStacksAdministrativeOutput) ToGetStacksAdministrativeOutput() GetStacksAdministrativeOutput { + return o +} + +func (o GetStacksAdministrativeOutput) ToGetStacksAdministrativeOutputWithContext(ctx context.Context) GetStacksAdministrativeOutput { + return o +} + +func (o GetStacksAdministrativeOutput) ToGetStacksAdministrativePtrOutput() GetStacksAdministrativePtrOutput { + return o.ToGetStacksAdministrativePtrOutputWithContext(context.Background()) +} + +func (o GetStacksAdministrativeOutput) ToGetStacksAdministrativePtrOutputWithContext(ctx context.Context) GetStacksAdministrativePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksAdministrative) *GetStacksAdministrative { + return &v + }).(GetStacksAdministrativePtrOutput) +} + +func (o GetStacksAdministrativeOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksAdministrative] { + return pulumix.Output[GetStacksAdministrative]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksAdministrativeOutput) Equals() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetStacksAdministrative) *bool { return v.Equals }).(pulumi.BoolPtrOutput) +} + +type GetStacksAdministrativePtrOutput struct{ *pulumi.OutputState } + +func (GetStacksAdministrativePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksAdministrative)(nil)).Elem() +} + +func (o GetStacksAdministrativePtrOutput) ToGetStacksAdministrativePtrOutput() GetStacksAdministrativePtrOutput { + return o +} + +func (o GetStacksAdministrativePtrOutput) ToGetStacksAdministrativePtrOutputWithContext(ctx context.Context) GetStacksAdministrativePtrOutput { + return o +} + +func (o GetStacksAdministrativePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksAdministrative] { + return pulumix.Output[*GetStacksAdministrative]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksAdministrativePtrOutput) Elem() GetStacksAdministrativeOutput { + return o.ApplyT(func(v *GetStacksAdministrative) GetStacksAdministrative { + if v != nil { + return *v + } + var ret GetStacksAdministrative + return ret + }).(GetStacksAdministrativeOutput) +} + +func (o GetStacksAdministrativePtrOutput) Equals() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *GetStacksAdministrative) *bool { + if v == nil { + return nil + } + return v.Equals + }).(pulumi.BoolPtrOutput) +} + +type GetStacksBranch struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetStacksBranchInput is an input type that accepts GetStacksBranchArgs and GetStacksBranchOutput values. +// You can construct a concrete instance of `GetStacksBranchInput` via: +// +// GetStacksBranchArgs{...} +type GetStacksBranchInput interface { + pulumi.Input + + ToGetStacksBranchOutput() GetStacksBranchOutput + ToGetStacksBranchOutputWithContext(context.Context) GetStacksBranchOutput +} + +type GetStacksBranchArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` +} + +func (GetStacksBranchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksBranch)(nil)).Elem() +} + +func (i GetStacksBranchArgs) ToGetStacksBranchOutput() GetStacksBranchOutput { + return i.ToGetStacksBranchOutputWithContext(context.Background()) +} + +func (i GetStacksBranchArgs) ToGetStacksBranchOutputWithContext(ctx context.Context) GetStacksBranchOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksBranchOutput) +} + +func (i GetStacksBranchArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksBranch] { + return pulumix.Output[GetStacksBranch]{ + OutputState: i.ToGetStacksBranchOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksBranchArgs) ToGetStacksBranchPtrOutput() GetStacksBranchPtrOutput { + return i.ToGetStacksBranchPtrOutputWithContext(context.Background()) +} + +func (i GetStacksBranchArgs) ToGetStacksBranchPtrOutputWithContext(ctx context.Context) GetStacksBranchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksBranchOutput).ToGetStacksBranchPtrOutputWithContext(ctx) +} + +// GetStacksBranchPtrInput is an input type that accepts GetStacksBranchArgs, GetStacksBranchPtr and GetStacksBranchPtrOutput values. +// You can construct a concrete instance of `GetStacksBranchPtrInput` via: +// +// GetStacksBranchArgs{...} +// +// or: +// +// nil +type GetStacksBranchPtrInput interface { + pulumi.Input + + ToGetStacksBranchPtrOutput() GetStacksBranchPtrOutput + ToGetStacksBranchPtrOutputWithContext(context.Context) GetStacksBranchPtrOutput +} + +type getStacksBranchPtrType GetStacksBranchArgs + +func GetStacksBranchPtr(v *GetStacksBranchArgs) GetStacksBranchPtrInput { + return (*getStacksBranchPtrType)(v) +} + +func (*getStacksBranchPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksBranch)(nil)).Elem() +} + +func (i *getStacksBranchPtrType) ToGetStacksBranchPtrOutput() GetStacksBranchPtrOutput { + return i.ToGetStacksBranchPtrOutputWithContext(context.Background()) +} + +func (i *getStacksBranchPtrType) ToGetStacksBranchPtrOutputWithContext(ctx context.Context) GetStacksBranchPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksBranchPtrOutput) +} + +func (i *getStacksBranchPtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksBranch] { + return pulumix.Output[*GetStacksBranch]{ + OutputState: i.ToGetStacksBranchPtrOutputWithContext(ctx).OutputState, + } +} + +type GetStacksBranchOutput struct{ *pulumi.OutputState } + +func (GetStacksBranchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksBranch)(nil)).Elem() +} + +func (o GetStacksBranchOutput) ToGetStacksBranchOutput() GetStacksBranchOutput { + return o +} + +func (o GetStacksBranchOutput) ToGetStacksBranchOutputWithContext(ctx context.Context) GetStacksBranchOutput { + return o +} + +func (o GetStacksBranchOutput) ToGetStacksBranchPtrOutput() GetStacksBranchPtrOutput { + return o.ToGetStacksBranchPtrOutputWithContext(context.Background()) +} + +func (o GetStacksBranchOutput) ToGetStacksBranchPtrOutputWithContext(ctx context.Context) GetStacksBranchPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksBranch) *GetStacksBranch { + return &v + }).(GetStacksBranchPtrOutput) +} + +func (o GetStacksBranchOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksBranch] { + return pulumix.Output[GetStacksBranch]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksBranchOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksBranch) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetStacksBranchPtrOutput struct{ *pulumi.OutputState } + +func (GetStacksBranchPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksBranch)(nil)).Elem() +} + +func (o GetStacksBranchPtrOutput) ToGetStacksBranchPtrOutput() GetStacksBranchPtrOutput { + return o +} + +func (o GetStacksBranchPtrOutput) ToGetStacksBranchPtrOutputWithContext(ctx context.Context) GetStacksBranchPtrOutput { + return o +} + +func (o GetStacksBranchPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksBranch] { + return pulumix.Output[*GetStacksBranch]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksBranchPtrOutput) Elem() GetStacksBranchOutput { + return o.ApplyT(func(v *GetStacksBranch) GetStacksBranch { + if v != nil { + return *v + } + var ret GetStacksBranch + return ret + }).(GetStacksBranchOutput) +} + +func (o GetStacksBranchPtrOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GetStacksBranch) []string { + if v == nil { + return nil + } + return v.AnyOfs + }).(pulumi.StringArrayOutput) +} + +type GetStacksCommit struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetStacksCommitInput is an input type that accepts GetStacksCommitArgs and GetStacksCommitOutput values. +// You can construct a concrete instance of `GetStacksCommitInput` via: +// +// GetStacksCommitArgs{...} +type GetStacksCommitInput interface { + pulumi.Input + + ToGetStacksCommitOutput() GetStacksCommitOutput + ToGetStacksCommitOutputWithContext(context.Context) GetStacksCommitOutput +} + +type GetStacksCommitArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` +} + +func (GetStacksCommitArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksCommit)(nil)).Elem() +} + +func (i GetStacksCommitArgs) ToGetStacksCommitOutput() GetStacksCommitOutput { + return i.ToGetStacksCommitOutputWithContext(context.Background()) +} + +func (i GetStacksCommitArgs) ToGetStacksCommitOutputWithContext(ctx context.Context) GetStacksCommitOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksCommitOutput) +} + +func (i GetStacksCommitArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksCommit] { + return pulumix.Output[GetStacksCommit]{ + OutputState: i.ToGetStacksCommitOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksCommitArgs) ToGetStacksCommitPtrOutput() GetStacksCommitPtrOutput { + return i.ToGetStacksCommitPtrOutputWithContext(context.Background()) +} + +func (i GetStacksCommitArgs) ToGetStacksCommitPtrOutputWithContext(ctx context.Context) GetStacksCommitPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksCommitOutput).ToGetStacksCommitPtrOutputWithContext(ctx) +} + +// GetStacksCommitPtrInput is an input type that accepts GetStacksCommitArgs, GetStacksCommitPtr and GetStacksCommitPtrOutput values. +// You can construct a concrete instance of `GetStacksCommitPtrInput` via: +// +// GetStacksCommitArgs{...} +// +// or: +// +// nil +type GetStacksCommitPtrInput interface { + pulumi.Input + + ToGetStacksCommitPtrOutput() GetStacksCommitPtrOutput + ToGetStacksCommitPtrOutputWithContext(context.Context) GetStacksCommitPtrOutput +} + +type getStacksCommitPtrType GetStacksCommitArgs + +func GetStacksCommitPtr(v *GetStacksCommitArgs) GetStacksCommitPtrInput { + return (*getStacksCommitPtrType)(v) +} + +func (*getStacksCommitPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksCommit)(nil)).Elem() +} + +func (i *getStacksCommitPtrType) ToGetStacksCommitPtrOutput() GetStacksCommitPtrOutput { + return i.ToGetStacksCommitPtrOutputWithContext(context.Background()) +} + +func (i *getStacksCommitPtrType) ToGetStacksCommitPtrOutputWithContext(ctx context.Context) GetStacksCommitPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksCommitPtrOutput) +} + +func (i *getStacksCommitPtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksCommit] { + return pulumix.Output[*GetStacksCommit]{ + OutputState: i.ToGetStacksCommitPtrOutputWithContext(ctx).OutputState, + } +} + +type GetStacksCommitOutput struct{ *pulumi.OutputState } + +func (GetStacksCommitOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksCommit)(nil)).Elem() +} + +func (o GetStacksCommitOutput) ToGetStacksCommitOutput() GetStacksCommitOutput { + return o +} + +func (o GetStacksCommitOutput) ToGetStacksCommitOutputWithContext(ctx context.Context) GetStacksCommitOutput { + return o +} + +func (o GetStacksCommitOutput) ToGetStacksCommitPtrOutput() GetStacksCommitPtrOutput { + return o.ToGetStacksCommitPtrOutputWithContext(context.Background()) +} + +func (o GetStacksCommitOutput) ToGetStacksCommitPtrOutputWithContext(ctx context.Context) GetStacksCommitPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksCommit) *GetStacksCommit { + return &v + }).(GetStacksCommitPtrOutput) +} + +func (o GetStacksCommitOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksCommit] { + return pulumix.Output[GetStacksCommit]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksCommitOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksCommit) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetStacksCommitPtrOutput struct{ *pulumi.OutputState } + +func (GetStacksCommitPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksCommit)(nil)).Elem() +} + +func (o GetStacksCommitPtrOutput) ToGetStacksCommitPtrOutput() GetStacksCommitPtrOutput { + return o +} + +func (o GetStacksCommitPtrOutput) ToGetStacksCommitPtrOutputWithContext(ctx context.Context) GetStacksCommitPtrOutput { + return o +} + +func (o GetStacksCommitPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksCommit] { + return pulumix.Output[*GetStacksCommit]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksCommitPtrOutput) Elem() GetStacksCommitOutput { + return o.ApplyT(func(v *GetStacksCommit) GetStacksCommit { + if v != nil { + return *v + } + var ret GetStacksCommit + return ret + }).(GetStacksCommitOutput) +} + +func (o GetStacksCommitPtrOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GetStacksCommit) []string { + if v == nil { + return nil + } + return v.AnyOfs + }).(pulumi.StringArrayOutput) +} + +type GetStacksLabel struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetStacksLabelInput is an input type that accepts GetStacksLabelArgs and GetStacksLabelOutput values. +// You can construct a concrete instance of `GetStacksLabelInput` via: +// +// GetStacksLabelArgs{...} +type GetStacksLabelInput interface { + pulumi.Input + + ToGetStacksLabelOutput() GetStacksLabelOutput + ToGetStacksLabelOutputWithContext(context.Context) GetStacksLabelOutput +} + +type GetStacksLabelArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` +} + +func (GetStacksLabelArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksLabel)(nil)).Elem() +} + +func (i GetStacksLabelArgs) ToGetStacksLabelOutput() GetStacksLabelOutput { + return i.ToGetStacksLabelOutputWithContext(context.Background()) +} + +func (i GetStacksLabelArgs) ToGetStacksLabelOutputWithContext(ctx context.Context) GetStacksLabelOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksLabelOutput) +} + +func (i GetStacksLabelArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksLabel] { + return pulumix.Output[GetStacksLabel]{ + OutputState: i.ToGetStacksLabelOutputWithContext(ctx).OutputState, + } +} + +// GetStacksLabelArrayInput is an input type that accepts GetStacksLabelArray and GetStacksLabelArrayOutput values. +// You can construct a concrete instance of `GetStacksLabelArrayInput` via: +// +// GetStacksLabelArray{ GetStacksLabelArgs{...} } +type GetStacksLabelArrayInput interface { + pulumi.Input + + ToGetStacksLabelArrayOutput() GetStacksLabelArrayOutput + ToGetStacksLabelArrayOutputWithContext(context.Context) GetStacksLabelArrayOutput +} + +type GetStacksLabelArray []GetStacksLabelInput + +func (GetStacksLabelArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksLabel)(nil)).Elem() +} + +func (i GetStacksLabelArray) ToGetStacksLabelArrayOutput() GetStacksLabelArrayOutput { + return i.ToGetStacksLabelArrayOutputWithContext(context.Background()) +} + +func (i GetStacksLabelArray) ToGetStacksLabelArrayOutputWithContext(ctx context.Context) GetStacksLabelArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksLabelArrayOutput) +} + +func (i GetStacksLabelArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksLabel] { + return pulumix.Output[[]GetStacksLabel]{ + OutputState: i.ToGetStacksLabelArrayOutputWithContext(ctx).OutputState, + } +} + +type GetStacksLabelOutput struct{ *pulumi.OutputState } + +func (GetStacksLabelOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksLabel)(nil)).Elem() +} + +func (o GetStacksLabelOutput) ToGetStacksLabelOutput() GetStacksLabelOutput { + return o +} + +func (o GetStacksLabelOutput) ToGetStacksLabelOutputWithContext(ctx context.Context) GetStacksLabelOutput { + return o +} + +func (o GetStacksLabelOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksLabel] { + return pulumix.Output[GetStacksLabel]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksLabelOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksLabel) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetStacksLabelArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksLabelArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksLabel)(nil)).Elem() +} + +func (o GetStacksLabelArrayOutput) ToGetStacksLabelArrayOutput() GetStacksLabelArrayOutput { + return o +} + +func (o GetStacksLabelArrayOutput) ToGetStacksLabelArrayOutputWithContext(ctx context.Context) GetStacksLabelArrayOutput { + return o +} + +func (o GetStacksLabelArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksLabel] { + return pulumix.Output[[]GetStacksLabel]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksLabelArrayOutput) Index(i pulumi.IntInput) GetStacksLabelOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksLabel { + return vs[0].([]GetStacksLabel)[vs[1].(int)] + }).(GetStacksLabelOutput) +} + +type GetStacksLocked struct { + Equals *bool `pulumi:"equals"` +} + +// GetStacksLockedInput is an input type that accepts GetStacksLockedArgs and GetStacksLockedOutput values. +// You can construct a concrete instance of `GetStacksLockedInput` via: +// +// GetStacksLockedArgs{...} +type GetStacksLockedInput interface { + pulumi.Input + + ToGetStacksLockedOutput() GetStacksLockedOutput + ToGetStacksLockedOutputWithContext(context.Context) GetStacksLockedOutput +} + +type GetStacksLockedArgs struct { + Equals pulumi.BoolPtrInput `pulumi:"equals"` +} + +func (GetStacksLockedArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksLocked)(nil)).Elem() +} + +func (i GetStacksLockedArgs) ToGetStacksLockedOutput() GetStacksLockedOutput { + return i.ToGetStacksLockedOutputWithContext(context.Background()) +} + +func (i GetStacksLockedArgs) ToGetStacksLockedOutputWithContext(ctx context.Context) GetStacksLockedOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksLockedOutput) +} + +func (i GetStacksLockedArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksLocked] { + return pulumix.Output[GetStacksLocked]{ + OutputState: i.ToGetStacksLockedOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksLockedArgs) ToGetStacksLockedPtrOutput() GetStacksLockedPtrOutput { + return i.ToGetStacksLockedPtrOutputWithContext(context.Background()) +} + +func (i GetStacksLockedArgs) ToGetStacksLockedPtrOutputWithContext(ctx context.Context) GetStacksLockedPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksLockedOutput).ToGetStacksLockedPtrOutputWithContext(ctx) +} + +// GetStacksLockedPtrInput is an input type that accepts GetStacksLockedArgs, GetStacksLockedPtr and GetStacksLockedPtrOutput values. +// You can construct a concrete instance of `GetStacksLockedPtrInput` via: +// +// GetStacksLockedArgs{...} +// +// or: +// +// nil +type GetStacksLockedPtrInput interface { + pulumi.Input + + ToGetStacksLockedPtrOutput() GetStacksLockedPtrOutput + ToGetStacksLockedPtrOutputWithContext(context.Context) GetStacksLockedPtrOutput +} + +type getStacksLockedPtrType GetStacksLockedArgs + +func GetStacksLockedPtr(v *GetStacksLockedArgs) GetStacksLockedPtrInput { + return (*getStacksLockedPtrType)(v) +} + +func (*getStacksLockedPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksLocked)(nil)).Elem() +} + +func (i *getStacksLockedPtrType) ToGetStacksLockedPtrOutput() GetStacksLockedPtrOutput { + return i.ToGetStacksLockedPtrOutputWithContext(context.Background()) +} + +func (i *getStacksLockedPtrType) ToGetStacksLockedPtrOutputWithContext(ctx context.Context) GetStacksLockedPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksLockedPtrOutput) +} + +func (i *getStacksLockedPtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksLocked] { + return pulumix.Output[*GetStacksLocked]{ + OutputState: i.ToGetStacksLockedPtrOutputWithContext(ctx).OutputState, + } +} + +type GetStacksLockedOutput struct{ *pulumi.OutputState } + +func (GetStacksLockedOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksLocked)(nil)).Elem() +} + +func (o GetStacksLockedOutput) ToGetStacksLockedOutput() GetStacksLockedOutput { + return o +} + +func (o GetStacksLockedOutput) ToGetStacksLockedOutputWithContext(ctx context.Context) GetStacksLockedOutput { + return o +} + +func (o GetStacksLockedOutput) ToGetStacksLockedPtrOutput() GetStacksLockedPtrOutput { + return o.ToGetStacksLockedPtrOutputWithContext(context.Background()) +} + +func (o GetStacksLockedOutput) ToGetStacksLockedPtrOutputWithContext(ctx context.Context) GetStacksLockedPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksLocked) *GetStacksLocked { + return &v + }).(GetStacksLockedPtrOutput) +} + +func (o GetStacksLockedOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksLocked] { + return pulumix.Output[GetStacksLocked]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksLockedOutput) Equals() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetStacksLocked) *bool { return v.Equals }).(pulumi.BoolPtrOutput) +} + +type GetStacksLockedPtrOutput struct{ *pulumi.OutputState } + +func (GetStacksLockedPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksLocked)(nil)).Elem() +} + +func (o GetStacksLockedPtrOutput) ToGetStacksLockedPtrOutput() GetStacksLockedPtrOutput { + return o +} + +func (o GetStacksLockedPtrOutput) ToGetStacksLockedPtrOutputWithContext(ctx context.Context) GetStacksLockedPtrOutput { + return o +} + +func (o GetStacksLockedPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksLocked] { + return pulumix.Output[*GetStacksLocked]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksLockedPtrOutput) Elem() GetStacksLockedOutput { + return o.ApplyT(func(v *GetStacksLocked) GetStacksLocked { + if v != nil { + return *v + } + var ret GetStacksLocked + return ret + }).(GetStacksLockedOutput) +} + +func (o GetStacksLockedPtrOutput) Equals() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *GetStacksLocked) *bool { + if v == nil { + return nil + } + return v.Equals + }).(pulumi.BoolPtrOutput) +} + +type GetStacksName struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetStacksNameInput is an input type that accepts GetStacksNameArgs and GetStacksNameOutput values. +// You can construct a concrete instance of `GetStacksNameInput` via: +// +// GetStacksNameArgs{...} +type GetStacksNameInput interface { + pulumi.Input + + ToGetStacksNameOutput() GetStacksNameOutput + ToGetStacksNameOutputWithContext(context.Context) GetStacksNameOutput +} + +type GetStacksNameArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` +} + +func (GetStacksNameArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksName)(nil)).Elem() +} + +func (i GetStacksNameArgs) ToGetStacksNameOutput() GetStacksNameOutput { + return i.ToGetStacksNameOutputWithContext(context.Background()) +} + +func (i GetStacksNameArgs) ToGetStacksNameOutputWithContext(ctx context.Context) GetStacksNameOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksNameOutput) +} + +func (i GetStacksNameArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksName] { + return pulumix.Output[GetStacksName]{ + OutputState: i.ToGetStacksNameOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksNameArgs) ToGetStacksNamePtrOutput() GetStacksNamePtrOutput { + return i.ToGetStacksNamePtrOutputWithContext(context.Background()) +} + +func (i GetStacksNameArgs) ToGetStacksNamePtrOutputWithContext(ctx context.Context) GetStacksNamePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksNameOutput).ToGetStacksNamePtrOutputWithContext(ctx) +} + +// GetStacksNamePtrInput is an input type that accepts GetStacksNameArgs, GetStacksNamePtr and GetStacksNamePtrOutput values. +// You can construct a concrete instance of `GetStacksNamePtrInput` via: +// +// GetStacksNameArgs{...} +// +// or: +// +// nil +type GetStacksNamePtrInput interface { + pulumi.Input + + ToGetStacksNamePtrOutput() GetStacksNamePtrOutput + ToGetStacksNamePtrOutputWithContext(context.Context) GetStacksNamePtrOutput +} + +type getStacksNamePtrType GetStacksNameArgs + +func GetStacksNamePtr(v *GetStacksNameArgs) GetStacksNamePtrInput { + return (*getStacksNamePtrType)(v) +} + +func (*getStacksNamePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksName)(nil)).Elem() +} + +func (i *getStacksNamePtrType) ToGetStacksNamePtrOutput() GetStacksNamePtrOutput { + return i.ToGetStacksNamePtrOutputWithContext(context.Background()) +} + +func (i *getStacksNamePtrType) ToGetStacksNamePtrOutputWithContext(ctx context.Context) GetStacksNamePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksNamePtrOutput) +} + +func (i *getStacksNamePtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksName] { + return pulumix.Output[*GetStacksName]{ + OutputState: i.ToGetStacksNamePtrOutputWithContext(ctx).OutputState, + } +} + +type GetStacksNameOutput struct{ *pulumi.OutputState } + +func (GetStacksNameOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksName)(nil)).Elem() +} + +func (o GetStacksNameOutput) ToGetStacksNameOutput() GetStacksNameOutput { + return o +} + +func (o GetStacksNameOutput) ToGetStacksNameOutputWithContext(ctx context.Context) GetStacksNameOutput { + return o +} + +func (o GetStacksNameOutput) ToGetStacksNamePtrOutput() GetStacksNamePtrOutput { + return o.ToGetStacksNamePtrOutputWithContext(context.Background()) +} + +func (o GetStacksNameOutput) ToGetStacksNamePtrOutputWithContext(ctx context.Context) GetStacksNamePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksName) *GetStacksName { + return &v + }).(GetStacksNamePtrOutput) +} + +func (o GetStacksNameOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksName] { + return pulumix.Output[GetStacksName]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksNameOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksName) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetStacksNamePtrOutput struct{ *pulumi.OutputState } + +func (GetStacksNamePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksName)(nil)).Elem() +} + +func (o GetStacksNamePtrOutput) ToGetStacksNamePtrOutput() GetStacksNamePtrOutput { + return o +} + +func (o GetStacksNamePtrOutput) ToGetStacksNamePtrOutputWithContext(ctx context.Context) GetStacksNamePtrOutput { + return o +} + +func (o GetStacksNamePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksName] { + return pulumix.Output[*GetStacksName]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksNamePtrOutput) Elem() GetStacksNameOutput { + return o.ApplyT(func(v *GetStacksName) GetStacksName { + if v != nil { + return *v + } + var ret GetStacksName + return ret + }).(GetStacksNameOutput) +} + +func (o GetStacksNamePtrOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GetStacksName) []string { + if v == nil { + return nil + } + return v.AnyOfs + }).(pulumi.StringArrayOutput) +} + +type GetStacksProjectRoot struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetStacksProjectRootInput is an input type that accepts GetStacksProjectRootArgs and GetStacksProjectRootOutput values. +// You can construct a concrete instance of `GetStacksProjectRootInput` via: +// +// GetStacksProjectRootArgs{...} +type GetStacksProjectRootInput interface { + pulumi.Input + + ToGetStacksProjectRootOutput() GetStacksProjectRootOutput + ToGetStacksProjectRootOutputWithContext(context.Context) GetStacksProjectRootOutput +} + +type GetStacksProjectRootArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` +} + +func (GetStacksProjectRootArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksProjectRoot)(nil)).Elem() +} + +func (i GetStacksProjectRootArgs) ToGetStacksProjectRootOutput() GetStacksProjectRootOutput { + return i.ToGetStacksProjectRootOutputWithContext(context.Background()) +} + +func (i GetStacksProjectRootArgs) ToGetStacksProjectRootOutputWithContext(ctx context.Context) GetStacksProjectRootOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksProjectRootOutput) +} + +func (i GetStacksProjectRootArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksProjectRoot] { + return pulumix.Output[GetStacksProjectRoot]{ + OutputState: i.ToGetStacksProjectRootOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksProjectRootArgs) ToGetStacksProjectRootPtrOutput() GetStacksProjectRootPtrOutput { + return i.ToGetStacksProjectRootPtrOutputWithContext(context.Background()) +} + +func (i GetStacksProjectRootArgs) ToGetStacksProjectRootPtrOutputWithContext(ctx context.Context) GetStacksProjectRootPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksProjectRootOutput).ToGetStacksProjectRootPtrOutputWithContext(ctx) +} + +// GetStacksProjectRootPtrInput is an input type that accepts GetStacksProjectRootArgs, GetStacksProjectRootPtr and GetStacksProjectRootPtrOutput values. +// You can construct a concrete instance of `GetStacksProjectRootPtrInput` via: +// +// GetStacksProjectRootArgs{...} +// +// or: +// +// nil +type GetStacksProjectRootPtrInput interface { + pulumi.Input + + ToGetStacksProjectRootPtrOutput() GetStacksProjectRootPtrOutput + ToGetStacksProjectRootPtrOutputWithContext(context.Context) GetStacksProjectRootPtrOutput +} + +type getStacksProjectRootPtrType GetStacksProjectRootArgs + +func GetStacksProjectRootPtr(v *GetStacksProjectRootArgs) GetStacksProjectRootPtrInput { + return (*getStacksProjectRootPtrType)(v) +} + +func (*getStacksProjectRootPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksProjectRoot)(nil)).Elem() +} + +func (i *getStacksProjectRootPtrType) ToGetStacksProjectRootPtrOutput() GetStacksProjectRootPtrOutput { + return i.ToGetStacksProjectRootPtrOutputWithContext(context.Background()) +} + +func (i *getStacksProjectRootPtrType) ToGetStacksProjectRootPtrOutputWithContext(ctx context.Context) GetStacksProjectRootPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksProjectRootPtrOutput) +} + +func (i *getStacksProjectRootPtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksProjectRoot] { + return pulumix.Output[*GetStacksProjectRoot]{ + OutputState: i.ToGetStacksProjectRootPtrOutputWithContext(ctx).OutputState, + } +} + +type GetStacksProjectRootOutput struct{ *pulumi.OutputState } + +func (GetStacksProjectRootOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksProjectRoot)(nil)).Elem() +} + +func (o GetStacksProjectRootOutput) ToGetStacksProjectRootOutput() GetStacksProjectRootOutput { + return o +} + +func (o GetStacksProjectRootOutput) ToGetStacksProjectRootOutputWithContext(ctx context.Context) GetStacksProjectRootOutput { + return o +} + +func (o GetStacksProjectRootOutput) ToGetStacksProjectRootPtrOutput() GetStacksProjectRootPtrOutput { + return o.ToGetStacksProjectRootPtrOutputWithContext(context.Background()) +} + +func (o GetStacksProjectRootOutput) ToGetStacksProjectRootPtrOutputWithContext(ctx context.Context) GetStacksProjectRootPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksProjectRoot) *GetStacksProjectRoot { + return &v + }).(GetStacksProjectRootPtrOutput) +} + +func (o GetStacksProjectRootOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksProjectRoot] { + return pulumix.Output[GetStacksProjectRoot]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksProjectRootOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksProjectRoot) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetStacksProjectRootPtrOutput struct{ *pulumi.OutputState } + +func (GetStacksProjectRootPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksProjectRoot)(nil)).Elem() +} + +func (o GetStacksProjectRootPtrOutput) ToGetStacksProjectRootPtrOutput() GetStacksProjectRootPtrOutput { + return o +} + +func (o GetStacksProjectRootPtrOutput) ToGetStacksProjectRootPtrOutputWithContext(ctx context.Context) GetStacksProjectRootPtrOutput { + return o +} + +func (o GetStacksProjectRootPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksProjectRoot] { + return pulumix.Output[*GetStacksProjectRoot]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksProjectRootPtrOutput) Elem() GetStacksProjectRootOutput { + return o.ApplyT(func(v *GetStacksProjectRoot) GetStacksProjectRoot { + if v != nil { + return *v + } + var ret GetStacksProjectRoot + return ret + }).(GetStacksProjectRootOutput) +} + +func (o GetStacksProjectRootPtrOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GetStacksProjectRoot) []string { + if v == nil { + return nil + } + return v.AnyOfs + }).(pulumi.StringArrayOutput) +} + +type GetStacksRepository struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetStacksRepositoryInput is an input type that accepts GetStacksRepositoryArgs and GetStacksRepositoryOutput values. +// You can construct a concrete instance of `GetStacksRepositoryInput` via: +// +// GetStacksRepositoryArgs{...} +type GetStacksRepositoryInput interface { + pulumi.Input + + ToGetStacksRepositoryOutput() GetStacksRepositoryOutput + ToGetStacksRepositoryOutputWithContext(context.Context) GetStacksRepositoryOutput +} + +type GetStacksRepositoryArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` +} + +func (GetStacksRepositoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksRepository)(nil)).Elem() +} + +func (i GetStacksRepositoryArgs) ToGetStacksRepositoryOutput() GetStacksRepositoryOutput { + return i.ToGetStacksRepositoryOutputWithContext(context.Background()) +} + +func (i GetStacksRepositoryArgs) ToGetStacksRepositoryOutputWithContext(ctx context.Context) GetStacksRepositoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksRepositoryOutput) +} + +func (i GetStacksRepositoryArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksRepository] { + return pulumix.Output[GetStacksRepository]{ + OutputState: i.ToGetStacksRepositoryOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksRepositoryArgs) ToGetStacksRepositoryPtrOutput() GetStacksRepositoryPtrOutput { + return i.ToGetStacksRepositoryPtrOutputWithContext(context.Background()) +} + +func (i GetStacksRepositoryArgs) ToGetStacksRepositoryPtrOutputWithContext(ctx context.Context) GetStacksRepositoryPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksRepositoryOutput).ToGetStacksRepositoryPtrOutputWithContext(ctx) +} + +// GetStacksRepositoryPtrInput is an input type that accepts GetStacksRepositoryArgs, GetStacksRepositoryPtr and GetStacksRepositoryPtrOutput values. +// You can construct a concrete instance of `GetStacksRepositoryPtrInput` via: +// +// GetStacksRepositoryArgs{...} +// +// or: +// +// nil +type GetStacksRepositoryPtrInput interface { + pulumi.Input + + ToGetStacksRepositoryPtrOutput() GetStacksRepositoryPtrOutput + ToGetStacksRepositoryPtrOutputWithContext(context.Context) GetStacksRepositoryPtrOutput +} + +type getStacksRepositoryPtrType GetStacksRepositoryArgs + +func GetStacksRepositoryPtr(v *GetStacksRepositoryArgs) GetStacksRepositoryPtrInput { + return (*getStacksRepositoryPtrType)(v) +} + +func (*getStacksRepositoryPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksRepository)(nil)).Elem() +} + +func (i *getStacksRepositoryPtrType) ToGetStacksRepositoryPtrOutput() GetStacksRepositoryPtrOutput { + return i.ToGetStacksRepositoryPtrOutputWithContext(context.Background()) +} + +func (i *getStacksRepositoryPtrType) ToGetStacksRepositoryPtrOutputWithContext(ctx context.Context) GetStacksRepositoryPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksRepositoryPtrOutput) +} + +func (i *getStacksRepositoryPtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksRepository] { + return pulumix.Output[*GetStacksRepository]{ + OutputState: i.ToGetStacksRepositoryPtrOutputWithContext(ctx).OutputState, + } +} + +type GetStacksRepositoryOutput struct{ *pulumi.OutputState } + +func (GetStacksRepositoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksRepository)(nil)).Elem() +} + +func (o GetStacksRepositoryOutput) ToGetStacksRepositoryOutput() GetStacksRepositoryOutput { + return o +} + +func (o GetStacksRepositoryOutput) ToGetStacksRepositoryOutputWithContext(ctx context.Context) GetStacksRepositoryOutput { + return o +} + +func (o GetStacksRepositoryOutput) ToGetStacksRepositoryPtrOutput() GetStacksRepositoryPtrOutput { + return o.ToGetStacksRepositoryPtrOutputWithContext(context.Background()) +} + +func (o GetStacksRepositoryOutput) ToGetStacksRepositoryPtrOutputWithContext(ctx context.Context) GetStacksRepositoryPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksRepository) *GetStacksRepository { + return &v + }).(GetStacksRepositoryPtrOutput) +} + +func (o GetStacksRepositoryOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksRepository] { + return pulumix.Output[GetStacksRepository]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksRepositoryOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksRepository) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetStacksRepositoryPtrOutput struct{ *pulumi.OutputState } + +func (GetStacksRepositoryPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksRepository)(nil)).Elem() +} + +func (o GetStacksRepositoryPtrOutput) ToGetStacksRepositoryPtrOutput() GetStacksRepositoryPtrOutput { + return o +} + +func (o GetStacksRepositoryPtrOutput) ToGetStacksRepositoryPtrOutputWithContext(ctx context.Context) GetStacksRepositoryPtrOutput { + return o +} + +func (o GetStacksRepositoryPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksRepository] { + return pulumix.Output[*GetStacksRepository]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksRepositoryPtrOutput) Elem() GetStacksRepositoryOutput { + return o.ApplyT(func(v *GetStacksRepository) GetStacksRepository { + if v != nil { + return *v + } + var ret GetStacksRepository + return ret + }).(GetStacksRepositoryOutput) +} + +func (o GetStacksRepositoryPtrOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GetStacksRepository) []string { + if v == nil { + return nil + } + return v.AnyOfs + }).(pulumi.StringArrayOutput) +} + +type GetStacksStack struct { + Administrative bool `pulumi:"administrative"` + AfterApplies []string `pulumi:"afterApplies"` + AfterDestroys []string `pulumi:"afterDestroys"` + AfterInits []string `pulumi:"afterInits"` + AfterPerforms []string `pulumi:"afterPerforms"` + AfterPlans []string `pulumi:"afterPlans"` + AfterRuns []string `pulumi:"afterRuns"` + Ansibles []GetStacksStackAnsible `pulumi:"ansibles"` + Autodeploy bool `pulumi:"autodeploy"` + Autoretry bool `pulumi:"autoretry"` + AwsAssumeRolePolicyStatement string `pulumi:"awsAssumeRolePolicyStatement"` + AzureDevops []GetStacksStackAzureDevop `pulumi:"azureDevops"` + BeforeApplies []string `pulumi:"beforeApplies"` + BeforeDestroys []string `pulumi:"beforeDestroys"` + BeforeInits []string `pulumi:"beforeInits"` + BeforePerforms []string `pulumi:"beforePerforms"` + BeforePlans []string `pulumi:"beforePlans"` + BitbucketClouds []GetStacksStackBitbucketCloud `pulumi:"bitbucketClouds"` + BitbucketDatacenters []GetStacksStackBitbucketDatacenter `pulumi:"bitbucketDatacenters"` + Branch string `pulumi:"branch"` + Cloudformations []GetStacksStackCloudformation `pulumi:"cloudformations"` + Description string `pulumi:"description"` + EnableLocalPreview bool `pulumi:"enableLocalPreview"` + GithubEnterprises []GetStacksStackGithubEnterprise `pulumi:"githubEnterprises"` + Gitlabs []GetStacksStackGitlab `pulumi:"gitlabs"` + Kubernetes []GetStacksStackKubernete `pulumi:"kubernetes"` + Labels []string `pulumi:"labels"` + ManageState bool `pulumi:"manageState"` + Name string `pulumi:"name"` + ProjectRoot string `pulumi:"projectRoot"` + ProtectFromDeletion bool `pulumi:"protectFromDeletion"` + Pulumis []GetStacksStackPulumi `pulumi:"pulumis"` + RawGits []GetStacksStackRawGit `pulumi:"rawGits"` + Repository string `pulumi:"repository"` + RunnerImage string `pulumi:"runnerImage"` + Showcases []GetStacksStackShowcase `pulumi:"showcases"` + SpaceId string `pulumi:"spaceId"` + StackId string `pulumi:"stackId"` + TerraformExternalStateAccess bool `pulumi:"terraformExternalStateAccess"` + TerraformSmartSanitization bool `pulumi:"terraformSmartSanitization"` + TerraformVersion string `pulumi:"terraformVersion"` + TerraformWorkflowTool string `pulumi:"terraformWorkflowTool"` + TerraformWorkspace string `pulumi:"terraformWorkspace"` + WorkerPoolId string `pulumi:"workerPoolId"` +} + +// GetStacksStackInput is an input type that accepts GetStacksStackArgs and GetStacksStackOutput values. +// You can construct a concrete instance of `GetStacksStackInput` via: +// +// GetStacksStackArgs{...} +type GetStacksStackInput interface { + pulumi.Input + + ToGetStacksStackOutput() GetStacksStackOutput + ToGetStacksStackOutputWithContext(context.Context) GetStacksStackOutput +} + +type GetStacksStackArgs struct { + Administrative pulumi.BoolInput `pulumi:"administrative"` + AfterApplies pulumi.StringArrayInput `pulumi:"afterApplies"` + AfterDestroys pulumi.StringArrayInput `pulumi:"afterDestroys"` + AfterInits pulumi.StringArrayInput `pulumi:"afterInits"` + AfterPerforms pulumi.StringArrayInput `pulumi:"afterPerforms"` + AfterPlans pulumi.StringArrayInput `pulumi:"afterPlans"` + AfterRuns pulumi.StringArrayInput `pulumi:"afterRuns"` + Ansibles GetStacksStackAnsibleArrayInput `pulumi:"ansibles"` + Autodeploy pulumi.BoolInput `pulumi:"autodeploy"` + Autoretry pulumi.BoolInput `pulumi:"autoretry"` + AwsAssumeRolePolicyStatement pulumi.StringInput `pulumi:"awsAssumeRolePolicyStatement"` + AzureDevops GetStacksStackAzureDevopArrayInput `pulumi:"azureDevops"` + BeforeApplies pulumi.StringArrayInput `pulumi:"beforeApplies"` + BeforeDestroys pulumi.StringArrayInput `pulumi:"beforeDestroys"` + BeforeInits pulumi.StringArrayInput `pulumi:"beforeInits"` + BeforePerforms pulumi.StringArrayInput `pulumi:"beforePerforms"` + BeforePlans pulumi.StringArrayInput `pulumi:"beforePlans"` + BitbucketClouds GetStacksStackBitbucketCloudArrayInput `pulumi:"bitbucketClouds"` + BitbucketDatacenters GetStacksStackBitbucketDatacenterArrayInput `pulumi:"bitbucketDatacenters"` + Branch pulumi.StringInput `pulumi:"branch"` + Cloudformations GetStacksStackCloudformationArrayInput `pulumi:"cloudformations"` + Description pulumi.StringInput `pulumi:"description"` + EnableLocalPreview pulumi.BoolInput `pulumi:"enableLocalPreview"` + GithubEnterprises GetStacksStackGithubEnterpriseArrayInput `pulumi:"githubEnterprises"` + Gitlabs GetStacksStackGitlabArrayInput `pulumi:"gitlabs"` + Kubernetes GetStacksStackKuberneteArrayInput `pulumi:"kubernetes"` + Labels pulumi.StringArrayInput `pulumi:"labels"` + ManageState pulumi.BoolInput `pulumi:"manageState"` + Name pulumi.StringInput `pulumi:"name"` + ProjectRoot pulumi.StringInput `pulumi:"projectRoot"` + ProtectFromDeletion pulumi.BoolInput `pulumi:"protectFromDeletion"` + Pulumis GetStacksStackPulumiArrayInput `pulumi:"pulumis"` + RawGits GetStacksStackRawGitArrayInput `pulumi:"rawGits"` + Repository pulumi.StringInput `pulumi:"repository"` + RunnerImage pulumi.StringInput `pulumi:"runnerImage"` + Showcases GetStacksStackShowcaseArrayInput `pulumi:"showcases"` + SpaceId pulumi.StringInput `pulumi:"spaceId"` + StackId pulumi.StringInput `pulumi:"stackId"` + TerraformExternalStateAccess pulumi.BoolInput `pulumi:"terraformExternalStateAccess"` + TerraformSmartSanitization pulumi.BoolInput `pulumi:"terraformSmartSanitization"` + TerraformVersion pulumi.StringInput `pulumi:"terraformVersion"` + TerraformWorkflowTool pulumi.StringInput `pulumi:"terraformWorkflowTool"` + TerraformWorkspace pulumi.StringInput `pulumi:"terraformWorkspace"` + WorkerPoolId pulumi.StringInput `pulumi:"workerPoolId"` +} + +func (GetStacksStackArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStack)(nil)).Elem() +} + +func (i GetStacksStackArgs) ToGetStacksStackOutput() GetStacksStackOutput { + return i.ToGetStacksStackOutputWithContext(context.Background()) +} + +func (i GetStacksStackArgs) ToGetStacksStackOutputWithContext(ctx context.Context) GetStacksStackOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackOutput) +} + +func (i GetStacksStackArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStack] { + return pulumix.Output[GetStacksStack]{ + OutputState: i.ToGetStacksStackOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackArrayInput is an input type that accepts GetStacksStackArray and GetStacksStackArrayOutput values. +// You can construct a concrete instance of `GetStacksStackArrayInput` via: +// +// GetStacksStackArray{ GetStacksStackArgs{...} } +type GetStacksStackArrayInput interface { + pulumi.Input + + ToGetStacksStackArrayOutput() GetStacksStackArrayOutput + ToGetStacksStackArrayOutputWithContext(context.Context) GetStacksStackArrayOutput } -type GetModuleAzureDevopArgs struct { - Project pulumi.StringInput `pulumi:"project"` +type GetStacksStackArray []GetStacksStackInput + +func (GetStacksStackArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStack)(nil)).Elem() } -func (GetModuleAzureDevopArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleAzureDevop)(nil)).Elem() +func (i GetStacksStackArray) ToGetStacksStackArrayOutput() GetStacksStackArrayOutput { + return i.ToGetStacksStackArrayOutputWithContext(context.Background()) } -func (i GetModuleAzureDevopArgs) ToGetModuleAzureDevopOutput() GetModuleAzureDevopOutput { - return i.ToGetModuleAzureDevopOutputWithContext(context.Background()) +func (i GetStacksStackArray) ToGetStacksStackArrayOutputWithContext(ctx context.Context) GetStacksStackArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackArrayOutput) } -func (i GetModuleAzureDevopArgs) ToGetModuleAzureDevopOutputWithContext(ctx context.Context) GetModuleAzureDevopOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleAzureDevopOutput) +func (i GetStacksStackArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStack] { + return pulumix.Output[[]GetStacksStack]{ + OutputState: i.ToGetStacksStackArrayOutputWithContext(ctx).OutputState, + } } -// GetModuleAzureDevopArrayInput is an input type that accepts GetModuleAzureDevopArray and GetModuleAzureDevopArrayOutput values. -// You can construct a concrete instance of `GetModuleAzureDevopArrayInput` via: -// -// GetModuleAzureDevopArray{ GetModuleAzureDevopArgs{...} } -type GetModuleAzureDevopArrayInput interface { - pulumi.Input +type GetStacksStackOutput struct{ *pulumi.OutputState } - ToGetModuleAzureDevopArrayOutput() GetModuleAzureDevopArrayOutput - ToGetModuleAzureDevopArrayOutputWithContext(context.Context) GetModuleAzureDevopArrayOutput +func (GetStacksStackOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStack)(nil)).Elem() } -type GetModuleAzureDevopArray []GetModuleAzureDevopInput +func (o GetStacksStackOutput) ToGetStacksStackOutput() GetStacksStackOutput { + return o +} -func (GetModuleAzureDevopArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleAzureDevop)(nil)).Elem() +func (o GetStacksStackOutput) ToGetStacksStackOutputWithContext(ctx context.Context) GetStacksStackOutput { + return o } -func (i GetModuleAzureDevopArray) ToGetModuleAzureDevopArrayOutput() GetModuleAzureDevopArrayOutput { - return i.ToGetModuleAzureDevopArrayOutputWithContext(context.Background()) +func (o GetStacksStackOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStack] { + return pulumix.Output[GetStacksStack]{ + OutputState: o.OutputState, + } } -func (i GetModuleAzureDevopArray) ToGetModuleAzureDevopArrayOutputWithContext(ctx context.Context) GetModuleAzureDevopArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleAzureDevopArrayOutput) +func (o GetStacksStackOutput) Administrative() pulumi.BoolOutput { + return o.ApplyT(func(v GetStacksStack) bool { return v.Administrative }).(pulumi.BoolOutput) } -type GetModuleAzureDevopOutput struct{ *pulumi.OutputState } +func (o GetStacksStackOutput) AfterApplies() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.AfterApplies }).(pulumi.StringArrayOutput) +} -func (GetModuleAzureDevopOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleAzureDevop)(nil)).Elem() +func (o GetStacksStackOutput) AfterDestroys() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.AfterDestroys }).(pulumi.StringArrayOutput) } -func (o GetModuleAzureDevopOutput) ToGetModuleAzureDevopOutput() GetModuleAzureDevopOutput { - return o +func (o GetStacksStackOutput) AfterInits() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.AfterInits }).(pulumi.StringArrayOutput) } -func (o GetModuleAzureDevopOutput) ToGetModuleAzureDevopOutputWithContext(ctx context.Context) GetModuleAzureDevopOutput { - return o +func (o GetStacksStackOutput) AfterPerforms() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.AfterPerforms }).(pulumi.StringArrayOutput) } -func (o GetModuleAzureDevopOutput) Project() pulumi.StringOutput { - return o.ApplyT(func(v GetModuleAzureDevop) string { return v.Project }).(pulumi.StringOutput) +func (o GetStacksStackOutput) AfterPlans() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.AfterPlans }).(pulumi.StringArrayOutput) } -type GetModuleAzureDevopArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackOutput) AfterRuns() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.AfterRuns }).(pulumi.StringArrayOutput) +} -func (GetModuleAzureDevopArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleAzureDevop)(nil)).Elem() +func (o GetStacksStackOutput) Ansibles() GetStacksStackAnsibleArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackAnsible { return v.Ansibles }).(GetStacksStackAnsibleArrayOutput) } -func (o GetModuleAzureDevopArrayOutput) ToGetModuleAzureDevopArrayOutput() GetModuleAzureDevopArrayOutput { - return o +func (o GetStacksStackOutput) Autodeploy() pulumi.BoolOutput { + return o.ApplyT(func(v GetStacksStack) bool { return v.Autodeploy }).(pulumi.BoolOutput) } -func (o GetModuleAzureDevopArrayOutput) ToGetModuleAzureDevopArrayOutputWithContext(ctx context.Context) GetModuleAzureDevopArrayOutput { - return o +func (o GetStacksStackOutput) Autoretry() pulumi.BoolOutput { + return o.ApplyT(func(v GetStacksStack) bool { return v.Autoretry }).(pulumi.BoolOutput) } -func (o GetModuleAzureDevopArrayOutput) Index(i pulumi.IntInput) GetModuleAzureDevopOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleAzureDevop { - return vs[0].([]GetModuleAzureDevop)[vs[1].(int)] - }).(GetModuleAzureDevopOutput) +func (o GetStacksStackOutput) AwsAssumeRolePolicyStatement() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.AwsAssumeRolePolicyStatement }).(pulumi.StringOutput) } -type GetModuleBitbucketCloud struct { - Namespace string `pulumi:"namespace"` +func (o GetStacksStackOutput) AzureDevops() GetStacksStackAzureDevopArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackAzureDevop { return v.AzureDevops }).(GetStacksStackAzureDevopArrayOutput) } -// GetModuleBitbucketCloudInput is an input type that accepts GetModuleBitbucketCloudArgs and GetModuleBitbucketCloudOutput values. -// You can construct a concrete instance of `GetModuleBitbucketCloudInput` via: -// -// GetModuleBitbucketCloudArgs{...} -type GetModuleBitbucketCloudInput interface { - pulumi.Input +func (o GetStacksStackOutput) BeforeApplies() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.BeforeApplies }).(pulumi.StringArrayOutput) +} - ToGetModuleBitbucketCloudOutput() GetModuleBitbucketCloudOutput - ToGetModuleBitbucketCloudOutputWithContext(context.Context) GetModuleBitbucketCloudOutput +func (o GetStacksStackOutput) BeforeDestroys() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.BeforeDestroys }).(pulumi.StringArrayOutput) } -type GetModuleBitbucketCloudArgs struct { - Namespace pulumi.StringInput `pulumi:"namespace"` +func (o GetStacksStackOutput) BeforeInits() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.BeforeInits }).(pulumi.StringArrayOutput) } -func (GetModuleBitbucketCloudArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleBitbucketCloud)(nil)).Elem() +func (o GetStacksStackOutput) BeforePerforms() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.BeforePerforms }).(pulumi.StringArrayOutput) } -func (i GetModuleBitbucketCloudArgs) ToGetModuleBitbucketCloudOutput() GetModuleBitbucketCloudOutput { - return i.ToGetModuleBitbucketCloudOutputWithContext(context.Background()) +func (o GetStacksStackOutput) BeforePlans() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.BeforePlans }).(pulumi.StringArrayOutput) } -func (i GetModuleBitbucketCloudArgs) ToGetModuleBitbucketCloudOutputWithContext(ctx context.Context) GetModuleBitbucketCloudOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleBitbucketCloudOutput) +func (o GetStacksStackOutput) BitbucketClouds() GetStacksStackBitbucketCloudArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackBitbucketCloud { return v.BitbucketClouds }).(GetStacksStackBitbucketCloudArrayOutput) } -// GetModuleBitbucketCloudArrayInput is an input type that accepts GetModuleBitbucketCloudArray and GetModuleBitbucketCloudArrayOutput values. -// You can construct a concrete instance of `GetModuleBitbucketCloudArrayInput` via: -// -// GetModuleBitbucketCloudArray{ GetModuleBitbucketCloudArgs{...} } -type GetModuleBitbucketCloudArrayInput interface { - pulumi.Input +func (o GetStacksStackOutput) BitbucketDatacenters() GetStacksStackBitbucketDatacenterArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackBitbucketDatacenter { return v.BitbucketDatacenters }).(GetStacksStackBitbucketDatacenterArrayOutput) +} - ToGetModuleBitbucketCloudArrayOutput() GetModuleBitbucketCloudArrayOutput - ToGetModuleBitbucketCloudArrayOutputWithContext(context.Context) GetModuleBitbucketCloudArrayOutput +func (o GetStacksStackOutput) Branch() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.Branch }).(pulumi.StringOutput) } -type GetModuleBitbucketCloudArray []GetModuleBitbucketCloudInput +func (o GetStacksStackOutput) Cloudformations() GetStacksStackCloudformationArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackCloudformation { return v.Cloudformations }).(GetStacksStackCloudformationArrayOutput) +} -func (GetModuleBitbucketCloudArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleBitbucketCloud)(nil)).Elem() +func (o GetStacksStackOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.Description }).(pulumi.StringOutput) } -func (i GetModuleBitbucketCloudArray) ToGetModuleBitbucketCloudArrayOutput() GetModuleBitbucketCloudArrayOutput { - return i.ToGetModuleBitbucketCloudArrayOutputWithContext(context.Background()) +func (o GetStacksStackOutput) EnableLocalPreview() pulumi.BoolOutput { + return o.ApplyT(func(v GetStacksStack) bool { return v.EnableLocalPreview }).(pulumi.BoolOutput) } -func (i GetModuleBitbucketCloudArray) ToGetModuleBitbucketCloudArrayOutputWithContext(ctx context.Context) GetModuleBitbucketCloudArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleBitbucketCloudArrayOutput) +func (o GetStacksStackOutput) GithubEnterprises() GetStacksStackGithubEnterpriseArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackGithubEnterprise { return v.GithubEnterprises }).(GetStacksStackGithubEnterpriseArrayOutput) } -type GetModuleBitbucketCloudOutput struct{ *pulumi.OutputState } +func (o GetStacksStackOutput) Gitlabs() GetStacksStackGitlabArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackGitlab { return v.Gitlabs }).(GetStacksStackGitlabArrayOutput) +} -func (GetModuleBitbucketCloudOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleBitbucketCloud)(nil)).Elem() +func (o GetStacksStackOutput) Kubernetes() GetStacksStackKuberneteArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackKubernete { return v.Kubernetes }).(GetStacksStackKuberneteArrayOutput) } -func (o GetModuleBitbucketCloudOutput) ToGetModuleBitbucketCloudOutput() GetModuleBitbucketCloudOutput { - return o +func (o GetStacksStackOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksStack) []string { return v.Labels }).(pulumi.StringArrayOutput) } -func (o GetModuleBitbucketCloudOutput) ToGetModuleBitbucketCloudOutputWithContext(ctx context.Context) GetModuleBitbucketCloudOutput { - return o +func (o GetStacksStackOutput) ManageState() pulumi.BoolOutput { + return o.ApplyT(func(v GetStacksStack) bool { return v.ManageState }).(pulumi.BoolOutput) } -func (o GetModuleBitbucketCloudOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetModuleBitbucketCloud) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStackOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.Name }).(pulumi.StringOutput) } -type GetModuleBitbucketCloudArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackOutput) ProjectRoot() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.ProjectRoot }).(pulumi.StringOutput) +} -func (GetModuleBitbucketCloudArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleBitbucketCloud)(nil)).Elem() +func (o GetStacksStackOutput) ProtectFromDeletion() pulumi.BoolOutput { + return o.ApplyT(func(v GetStacksStack) bool { return v.ProtectFromDeletion }).(pulumi.BoolOutput) } -func (o GetModuleBitbucketCloudArrayOutput) ToGetModuleBitbucketCloudArrayOutput() GetModuleBitbucketCloudArrayOutput { +func (o GetStacksStackOutput) Pulumis() GetStacksStackPulumiArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackPulumi { return v.Pulumis }).(GetStacksStackPulumiArrayOutput) +} + +func (o GetStacksStackOutput) RawGits() GetStacksStackRawGitArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackRawGit { return v.RawGits }).(GetStacksStackRawGitArrayOutput) +} + +func (o GetStacksStackOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.Repository }).(pulumi.StringOutput) +} + +func (o GetStacksStackOutput) RunnerImage() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.RunnerImage }).(pulumi.StringOutput) +} + +func (o GetStacksStackOutput) Showcases() GetStacksStackShowcaseArrayOutput { + return o.ApplyT(func(v GetStacksStack) []GetStacksStackShowcase { return v.Showcases }).(GetStacksStackShowcaseArrayOutput) +} + +func (o GetStacksStackOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.SpaceId }).(pulumi.StringOutput) +} + +func (o GetStacksStackOutput) StackId() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.StackId }).(pulumi.StringOutput) +} + +func (o GetStacksStackOutput) TerraformExternalStateAccess() pulumi.BoolOutput { + return o.ApplyT(func(v GetStacksStack) bool { return v.TerraformExternalStateAccess }).(pulumi.BoolOutput) +} + +func (o GetStacksStackOutput) TerraformSmartSanitization() pulumi.BoolOutput { + return o.ApplyT(func(v GetStacksStack) bool { return v.TerraformSmartSanitization }).(pulumi.BoolOutput) +} + +func (o GetStacksStackOutput) TerraformVersion() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.TerraformVersion }).(pulumi.StringOutput) +} + +func (o GetStacksStackOutput) TerraformWorkflowTool() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.TerraformWorkflowTool }).(pulumi.StringOutput) +} + +func (o GetStacksStackOutput) TerraformWorkspace() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.TerraformWorkspace }).(pulumi.StringOutput) +} + +func (o GetStacksStackOutput) WorkerPoolId() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStack) string { return v.WorkerPoolId }).(pulumi.StringOutput) +} + +type GetStacksStackArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStack)(nil)).Elem() +} + +func (o GetStacksStackArrayOutput) ToGetStacksStackArrayOutput() GetStacksStackArrayOutput { return o } -func (o GetModuleBitbucketCloudArrayOutput) ToGetModuleBitbucketCloudArrayOutputWithContext(ctx context.Context) GetModuleBitbucketCloudArrayOutput { +func (o GetStacksStackArrayOutput) ToGetStacksStackArrayOutputWithContext(ctx context.Context) GetStacksStackArrayOutput { return o } -func (o GetModuleBitbucketCloudArrayOutput) Index(i pulumi.IntInput) GetModuleBitbucketCloudOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleBitbucketCloud { - return vs[0].([]GetModuleBitbucketCloud)[vs[1].(int)] - }).(GetModuleBitbucketCloudOutput) +func (o GetStacksStackArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStack] { + return pulumix.Output[[]GetStacksStack]{ + OutputState: o.OutputState, + } } -type GetModuleBitbucketDatacenter struct { - Namespace string `pulumi:"namespace"` +func (o GetStacksStackArrayOutput) Index(i pulumi.IntInput) GetStacksStackOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStack { + return vs[0].([]GetStacksStack)[vs[1].(int)] + }).(GetStacksStackOutput) } -// GetModuleBitbucketDatacenterInput is an input type that accepts GetModuleBitbucketDatacenterArgs and GetModuleBitbucketDatacenterOutput values. -// You can construct a concrete instance of `GetModuleBitbucketDatacenterInput` via: +type GetStacksStackAnsible struct { + Playbook string `pulumi:"playbook"` +} + +// GetStacksStackAnsibleInput is an input type that accepts GetStacksStackAnsibleArgs and GetStacksStackAnsibleOutput values. +// You can construct a concrete instance of `GetStacksStackAnsibleInput` via: // -// GetModuleBitbucketDatacenterArgs{...} -type GetModuleBitbucketDatacenterInput interface { +// GetStacksStackAnsibleArgs{...} +type GetStacksStackAnsibleInput interface { pulumi.Input - ToGetModuleBitbucketDatacenterOutput() GetModuleBitbucketDatacenterOutput - ToGetModuleBitbucketDatacenterOutputWithContext(context.Context) GetModuleBitbucketDatacenterOutput + ToGetStacksStackAnsibleOutput() GetStacksStackAnsibleOutput + ToGetStacksStackAnsibleOutputWithContext(context.Context) GetStacksStackAnsibleOutput } -type GetModuleBitbucketDatacenterArgs struct { - Namespace pulumi.StringInput `pulumi:"namespace"` +type GetStacksStackAnsibleArgs struct { + Playbook pulumi.StringInput `pulumi:"playbook"` } -func (GetModuleBitbucketDatacenterArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleBitbucketDatacenter)(nil)).Elem() +func (GetStacksStackAnsibleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackAnsible)(nil)).Elem() } -func (i GetModuleBitbucketDatacenterArgs) ToGetModuleBitbucketDatacenterOutput() GetModuleBitbucketDatacenterOutput { - return i.ToGetModuleBitbucketDatacenterOutputWithContext(context.Background()) +func (i GetStacksStackAnsibleArgs) ToGetStacksStackAnsibleOutput() GetStacksStackAnsibleOutput { + return i.ToGetStacksStackAnsibleOutputWithContext(context.Background()) } -func (i GetModuleBitbucketDatacenterArgs) ToGetModuleBitbucketDatacenterOutputWithContext(ctx context.Context) GetModuleBitbucketDatacenterOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleBitbucketDatacenterOutput) +func (i GetStacksStackAnsibleArgs) ToGetStacksStackAnsibleOutputWithContext(ctx context.Context) GetStacksStackAnsibleOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackAnsibleOutput) } -// GetModuleBitbucketDatacenterArrayInput is an input type that accepts GetModuleBitbucketDatacenterArray and GetModuleBitbucketDatacenterArrayOutput values. -// You can construct a concrete instance of `GetModuleBitbucketDatacenterArrayInput` via: +func (i GetStacksStackAnsibleArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackAnsible] { + return pulumix.Output[GetStacksStackAnsible]{ + OutputState: i.ToGetStacksStackAnsibleOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackAnsibleArrayInput is an input type that accepts GetStacksStackAnsibleArray and GetStacksStackAnsibleArrayOutput values. +// You can construct a concrete instance of `GetStacksStackAnsibleArrayInput` via: // -// GetModuleBitbucketDatacenterArray{ GetModuleBitbucketDatacenterArgs{...} } -type GetModuleBitbucketDatacenterArrayInput interface { +// GetStacksStackAnsibleArray{ GetStacksStackAnsibleArgs{...} } +type GetStacksStackAnsibleArrayInput interface { pulumi.Input - ToGetModuleBitbucketDatacenterArrayOutput() GetModuleBitbucketDatacenterArrayOutput - ToGetModuleBitbucketDatacenterArrayOutputWithContext(context.Context) GetModuleBitbucketDatacenterArrayOutput + ToGetStacksStackAnsibleArrayOutput() GetStacksStackAnsibleArrayOutput + ToGetStacksStackAnsibleArrayOutputWithContext(context.Context) GetStacksStackAnsibleArrayOutput } -type GetModuleBitbucketDatacenterArray []GetModuleBitbucketDatacenterInput +type GetStacksStackAnsibleArray []GetStacksStackAnsibleInput -func (GetModuleBitbucketDatacenterArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleBitbucketDatacenter)(nil)).Elem() +func (GetStacksStackAnsibleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackAnsible)(nil)).Elem() } -func (i GetModuleBitbucketDatacenterArray) ToGetModuleBitbucketDatacenterArrayOutput() GetModuleBitbucketDatacenterArrayOutput { - return i.ToGetModuleBitbucketDatacenterArrayOutputWithContext(context.Background()) +func (i GetStacksStackAnsibleArray) ToGetStacksStackAnsibleArrayOutput() GetStacksStackAnsibleArrayOutput { + return i.ToGetStacksStackAnsibleArrayOutputWithContext(context.Background()) } -func (i GetModuleBitbucketDatacenterArray) ToGetModuleBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetModuleBitbucketDatacenterArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleBitbucketDatacenterArrayOutput) +func (i GetStacksStackAnsibleArray) ToGetStacksStackAnsibleArrayOutputWithContext(ctx context.Context) GetStacksStackAnsibleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackAnsibleArrayOutput) } -type GetModuleBitbucketDatacenterOutput struct{ *pulumi.OutputState } +func (i GetStacksStackAnsibleArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackAnsible] { + return pulumix.Output[[]GetStacksStackAnsible]{ + OutputState: i.ToGetStacksStackAnsibleArrayOutputWithContext(ctx).OutputState, + } +} -func (GetModuleBitbucketDatacenterOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleBitbucketDatacenter)(nil)).Elem() +type GetStacksStackAnsibleOutput struct{ *pulumi.OutputState } + +func (GetStacksStackAnsibleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackAnsible)(nil)).Elem() } -func (o GetModuleBitbucketDatacenterOutput) ToGetModuleBitbucketDatacenterOutput() GetModuleBitbucketDatacenterOutput { +func (o GetStacksStackAnsibleOutput) ToGetStacksStackAnsibleOutput() GetStacksStackAnsibleOutput { return o } -func (o GetModuleBitbucketDatacenterOutput) ToGetModuleBitbucketDatacenterOutputWithContext(ctx context.Context) GetModuleBitbucketDatacenterOutput { +func (o GetStacksStackAnsibleOutput) ToGetStacksStackAnsibleOutputWithContext(ctx context.Context) GetStacksStackAnsibleOutput { return o } -func (o GetModuleBitbucketDatacenterOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetModuleBitbucketDatacenter) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStackAnsibleOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackAnsible] { + return pulumix.Output[GetStacksStackAnsible]{ + OutputState: o.OutputState, + } } -type GetModuleBitbucketDatacenterArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackAnsibleOutput) Playbook() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackAnsible) string { return v.Playbook }).(pulumi.StringOutput) +} -func (GetModuleBitbucketDatacenterArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleBitbucketDatacenter)(nil)).Elem() +type GetStacksStackAnsibleArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackAnsibleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackAnsible)(nil)).Elem() } -func (o GetModuleBitbucketDatacenterArrayOutput) ToGetModuleBitbucketDatacenterArrayOutput() GetModuleBitbucketDatacenterArrayOutput { +func (o GetStacksStackAnsibleArrayOutput) ToGetStacksStackAnsibleArrayOutput() GetStacksStackAnsibleArrayOutput { return o } -func (o GetModuleBitbucketDatacenterArrayOutput) ToGetModuleBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetModuleBitbucketDatacenterArrayOutput { +func (o GetStacksStackAnsibleArrayOutput) ToGetStacksStackAnsibleArrayOutputWithContext(ctx context.Context) GetStacksStackAnsibleArrayOutput { return o } -func (o GetModuleBitbucketDatacenterArrayOutput) Index(i pulumi.IntInput) GetModuleBitbucketDatacenterOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleBitbucketDatacenter { - return vs[0].([]GetModuleBitbucketDatacenter)[vs[1].(int)] - }).(GetModuleBitbucketDatacenterOutput) +func (o GetStacksStackAnsibleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackAnsible] { + return pulumix.Output[[]GetStacksStackAnsible]{ + OutputState: o.OutputState, + } } -type GetModuleGithubEnterprise struct { - Namespace string `pulumi:"namespace"` +func (o GetStacksStackAnsibleArrayOutput) Index(i pulumi.IntInput) GetStacksStackAnsibleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackAnsible { + return vs[0].([]GetStacksStackAnsible)[vs[1].(int)] + }).(GetStacksStackAnsibleOutput) } -// GetModuleGithubEnterpriseInput is an input type that accepts GetModuleGithubEnterpriseArgs and GetModuleGithubEnterpriseOutput values. -// You can construct a concrete instance of `GetModuleGithubEnterpriseInput` via: +type GetStacksStackAzureDevop struct { + Project string `pulumi:"project"` +} + +// GetStacksStackAzureDevopInput is an input type that accepts GetStacksStackAzureDevopArgs and GetStacksStackAzureDevopOutput values. +// You can construct a concrete instance of `GetStacksStackAzureDevopInput` via: // -// GetModuleGithubEnterpriseArgs{...} -type GetModuleGithubEnterpriseInput interface { +// GetStacksStackAzureDevopArgs{...} +type GetStacksStackAzureDevopInput interface { pulumi.Input - ToGetModuleGithubEnterpriseOutput() GetModuleGithubEnterpriseOutput - ToGetModuleGithubEnterpriseOutputWithContext(context.Context) GetModuleGithubEnterpriseOutput + ToGetStacksStackAzureDevopOutput() GetStacksStackAzureDevopOutput + ToGetStacksStackAzureDevopOutputWithContext(context.Context) GetStacksStackAzureDevopOutput } -type GetModuleGithubEnterpriseArgs struct { - Namespace pulumi.StringInput `pulumi:"namespace"` +type GetStacksStackAzureDevopArgs struct { + Project pulumi.StringInput `pulumi:"project"` } -func (GetModuleGithubEnterpriseArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleGithubEnterprise)(nil)).Elem() +func (GetStacksStackAzureDevopArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackAzureDevop)(nil)).Elem() } -func (i GetModuleGithubEnterpriseArgs) ToGetModuleGithubEnterpriseOutput() GetModuleGithubEnterpriseOutput { - return i.ToGetModuleGithubEnterpriseOutputWithContext(context.Background()) +func (i GetStacksStackAzureDevopArgs) ToGetStacksStackAzureDevopOutput() GetStacksStackAzureDevopOutput { + return i.ToGetStacksStackAzureDevopOutputWithContext(context.Background()) } -func (i GetModuleGithubEnterpriseArgs) ToGetModuleGithubEnterpriseOutputWithContext(ctx context.Context) GetModuleGithubEnterpriseOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleGithubEnterpriseOutput) +func (i GetStacksStackAzureDevopArgs) ToGetStacksStackAzureDevopOutputWithContext(ctx context.Context) GetStacksStackAzureDevopOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackAzureDevopOutput) } -// GetModuleGithubEnterpriseArrayInput is an input type that accepts GetModuleGithubEnterpriseArray and GetModuleGithubEnterpriseArrayOutput values. -// You can construct a concrete instance of `GetModuleGithubEnterpriseArrayInput` via: +func (i GetStacksStackAzureDevopArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackAzureDevop] { + return pulumix.Output[GetStacksStackAzureDevop]{ + OutputState: i.ToGetStacksStackAzureDevopOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackAzureDevopArrayInput is an input type that accepts GetStacksStackAzureDevopArray and GetStacksStackAzureDevopArrayOutput values. +// You can construct a concrete instance of `GetStacksStackAzureDevopArrayInput` via: // -// GetModuleGithubEnterpriseArray{ GetModuleGithubEnterpriseArgs{...} } -type GetModuleGithubEnterpriseArrayInput interface { +// GetStacksStackAzureDevopArray{ GetStacksStackAzureDevopArgs{...} } +type GetStacksStackAzureDevopArrayInput interface { pulumi.Input - ToGetModuleGithubEnterpriseArrayOutput() GetModuleGithubEnterpriseArrayOutput - ToGetModuleGithubEnterpriseArrayOutputWithContext(context.Context) GetModuleGithubEnterpriseArrayOutput + ToGetStacksStackAzureDevopArrayOutput() GetStacksStackAzureDevopArrayOutput + ToGetStacksStackAzureDevopArrayOutputWithContext(context.Context) GetStacksStackAzureDevopArrayOutput } -type GetModuleGithubEnterpriseArray []GetModuleGithubEnterpriseInput +type GetStacksStackAzureDevopArray []GetStacksStackAzureDevopInput -func (GetModuleGithubEnterpriseArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleGithubEnterprise)(nil)).Elem() +func (GetStacksStackAzureDevopArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackAzureDevop)(nil)).Elem() } -func (i GetModuleGithubEnterpriseArray) ToGetModuleGithubEnterpriseArrayOutput() GetModuleGithubEnterpriseArrayOutput { - return i.ToGetModuleGithubEnterpriseArrayOutputWithContext(context.Background()) +func (i GetStacksStackAzureDevopArray) ToGetStacksStackAzureDevopArrayOutput() GetStacksStackAzureDevopArrayOutput { + return i.ToGetStacksStackAzureDevopArrayOutputWithContext(context.Background()) } -func (i GetModuleGithubEnterpriseArray) ToGetModuleGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetModuleGithubEnterpriseArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleGithubEnterpriseArrayOutput) +func (i GetStacksStackAzureDevopArray) ToGetStacksStackAzureDevopArrayOutputWithContext(ctx context.Context) GetStacksStackAzureDevopArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackAzureDevopArrayOutput) } -type GetModuleGithubEnterpriseOutput struct{ *pulumi.OutputState } +func (i GetStacksStackAzureDevopArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackAzureDevop] { + return pulumix.Output[[]GetStacksStackAzureDevop]{ + OutputState: i.ToGetStacksStackAzureDevopArrayOutputWithContext(ctx).OutputState, + } +} -func (GetModuleGithubEnterpriseOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleGithubEnterprise)(nil)).Elem() +type GetStacksStackAzureDevopOutput struct{ *pulumi.OutputState } + +func (GetStacksStackAzureDevopOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackAzureDevop)(nil)).Elem() } -func (o GetModuleGithubEnterpriseOutput) ToGetModuleGithubEnterpriseOutput() GetModuleGithubEnterpriseOutput { +func (o GetStacksStackAzureDevopOutput) ToGetStacksStackAzureDevopOutput() GetStacksStackAzureDevopOutput { return o } -func (o GetModuleGithubEnterpriseOutput) ToGetModuleGithubEnterpriseOutputWithContext(ctx context.Context) GetModuleGithubEnterpriseOutput { +func (o GetStacksStackAzureDevopOutput) ToGetStacksStackAzureDevopOutputWithContext(ctx context.Context) GetStacksStackAzureDevopOutput { return o } -func (o GetModuleGithubEnterpriseOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetModuleGithubEnterprise) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStackAzureDevopOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackAzureDevop] { + return pulumix.Output[GetStacksStackAzureDevop]{ + OutputState: o.OutputState, + } } -type GetModuleGithubEnterpriseArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackAzureDevopOutput) Project() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackAzureDevop) string { return v.Project }).(pulumi.StringOutput) +} -func (GetModuleGithubEnterpriseArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleGithubEnterprise)(nil)).Elem() +type GetStacksStackAzureDevopArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackAzureDevopArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackAzureDevop)(nil)).Elem() } -func (o GetModuleGithubEnterpriseArrayOutput) ToGetModuleGithubEnterpriseArrayOutput() GetModuleGithubEnterpriseArrayOutput { +func (o GetStacksStackAzureDevopArrayOutput) ToGetStacksStackAzureDevopArrayOutput() GetStacksStackAzureDevopArrayOutput { return o } -func (o GetModuleGithubEnterpriseArrayOutput) ToGetModuleGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetModuleGithubEnterpriseArrayOutput { +func (o GetStacksStackAzureDevopArrayOutput) ToGetStacksStackAzureDevopArrayOutputWithContext(ctx context.Context) GetStacksStackAzureDevopArrayOutput { return o } -func (o GetModuleGithubEnterpriseArrayOutput) Index(i pulumi.IntInput) GetModuleGithubEnterpriseOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleGithubEnterprise { - return vs[0].([]GetModuleGithubEnterprise)[vs[1].(int)] - }).(GetModuleGithubEnterpriseOutput) +func (o GetStacksStackAzureDevopArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackAzureDevop] { + return pulumix.Output[[]GetStacksStackAzureDevop]{ + OutputState: o.OutputState, + } } -type GetModuleGitlab struct { +func (o GetStacksStackAzureDevopArrayOutput) Index(i pulumi.IntInput) GetStacksStackAzureDevopOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackAzureDevop { + return vs[0].([]GetStacksStackAzureDevop)[vs[1].(int)] + }).(GetStacksStackAzureDevopOutput) +} + +type GetStacksStackBitbucketCloud struct { Namespace string `pulumi:"namespace"` } -// GetModuleGitlabInput is an input type that accepts GetModuleGitlabArgs and GetModuleGitlabOutput values. -// You can construct a concrete instance of `GetModuleGitlabInput` via: -// -// GetModuleGitlabArgs{...} -type GetModuleGitlabInput interface { +// GetStacksStackBitbucketCloudInput is an input type that accepts GetStacksStackBitbucketCloudArgs and GetStacksStackBitbucketCloudOutput values. +// You can construct a concrete instance of `GetStacksStackBitbucketCloudInput` via: +// +// GetStacksStackBitbucketCloudArgs{...} +type GetStacksStackBitbucketCloudInput interface { pulumi.Input - ToGetModuleGitlabOutput() GetModuleGitlabOutput - ToGetModuleGitlabOutputWithContext(context.Context) GetModuleGitlabOutput + ToGetStacksStackBitbucketCloudOutput() GetStacksStackBitbucketCloudOutput + ToGetStacksStackBitbucketCloudOutputWithContext(context.Context) GetStacksStackBitbucketCloudOutput } -type GetModuleGitlabArgs struct { +type GetStacksStackBitbucketCloudArgs struct { Namespace pulumi.StringInput `pulumi:"namespace"` } -func (GetModuleGitlabArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleGitlab)(nil)).Elem() +func (GetStacksStackBitbucketCloudArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackBitbucketCloud)(nil)).Elem() } -func (i GetModuleGitlabArgs) ToGetModuleGitlabOutput() GetModuleGitlabOutput { - return i.ToGetModuleGitlabOutputWithContext(context.Background()) +func (i GetStacksStackBitbucketCloudArgs) ToGetStacksStackBitbucketCloudOutput() GetStacksStackBitbucketCloudOutput { + return i.ToGetStacksStackBitbucketCloudOutputWithContext(context.Background()) } -func (i GetModuleGitlabArgs) ToGetModuleGitlabOutputWithContext(ctx context.Context) GetModuleGitlabOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleGitlabOutput) +func (i GetStacksStackBitbucketCloudArgs) ToGetStacksStackBitbucketCloudOutputWithContext(ctx context.Context) GetStacksStackBitbucketCloudOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackBitbucketCloudOutput) } -// GetModuleGitlabArrayInput is an input type that accepts GetModuleGitlabArray and GetModuleGitlabArrayOutput values. -// You can construct a concrete instance of `GetModuleGitlabArrayInput` via: +func (i GetStacksStackBitbucketCloudArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackBitbucketCloud] { + return pulumix.Output[GetStacksStackBitbucketCloud]{ + OutputState: i.ToGetStacksStackBitbucketCloudOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackBitbucketCloudArrayInput is an input type that accepts GetStacksStackBitbucketCloudArray and GetStacksStackBitbucketCloudArrayOutput values. +// You can construct a concrete instance of `GetStacksStackBitbucketCloudArrayInput` via: // -// GetModuleGitlabArray{ GetModuleGitlabArgs{...} } -type GetModuleGitlabArrayInput interface { +// GetStacksStackBitbucketCloudArray{ GetStacksStackBitbucketCloudArgs{...} } +type GetStacksStackBitbucketCloudArrayInput interface { pulumi.Input - ToGetModuleGitlabArrayOutput() GetModuleGitlabArrayOutput - ToGetModuleGitlabArrayOutputWithContext(context.Context) GetModuleGitlabArrayOutput + ToGetStacksStackBitbucketCloudArrayOutput() GetStacksStackBitbucketCloudArrayOutput + ToGetStacksStackBitbucketCloudArrayOutputWithContext(context.Context) GetStacksStackBitbucketCloudArrayOutput } -type GetModuleGitlabArray []GetModuleGitlabInput +type GetStacksStackBitbucketCloudArray []GetStacksStackBitbucketCloudInput -func (GetModuleGitlabArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleGitlab)(nil)).Elem() +func (GetStacksStackBitbucketCloudArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackBitbucketCloud)(nil)).Elem() } -func (i GetModuleGitlabArray) ToGetModuleGitlabArrayOutput() GetModuleGitlabArrayOutput { - return i.ToGetModuleGitlabArrayOutputWithContext(context.Background()) +func (i GetStacksStackBitbucketCloudArray) ToGetStacksStackBitbucketCloudArrayOutput() GetStacksStackBitbucketCloudArrayOutput { + return i.ToGetStacksStackBitbucketCloudArrayOutputWithContext(context.Background()) } -func (i GetModuleGitlabArray) ToGetModuleGitlabArrayOutputWithContext(ctx context.Context) GetModuleGitlabArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetModuleGitlabArrayOutput) +func (i GetStacksStackBitbucketCloudArray) ToGetStacksStackBitbucketCloudArrayOutputWithContext(ctx context.Context) GetStacksStackBitbucketCloudArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackBitbucketCloudArrayOutput) } -type GetModuleGitlabOutput struct{ *pulumi.OutputState } +func (i GetStacksStackBitbucketCloudArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackBitbucketCloud] { + return pulumix.Output[[]GetStacksStackBitbucketCloud]{ + OutputState: i.ToGetStacksStackBitbucketCloudArrayOutputWithContext(ctx).OutputState, + } +} -func (GetModuleGitlabOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetModuleGitlab)(nil)).Elem() +type GetStacksStackBitbucketCloudOutput struct{ *pulumi.OutputState } + +func (GetStacksStackBitbucketCloudOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackBitbucketCloud)(nil)).Elem() } -func (o GetModuleGitlabOutput) ToGetModuleGitlabOutput() GetModuleGitlabOutput { +func (o GetStacksStackBitbucketCloudOutput) ToGetStacksStackBitbucketCloudOutput() GetStacksStackBitbucketCloudOutput { return o } -func (o GetModuleGitlabOutput) ToGetModuleGitlabOutputWithContext(ctx context.Context) GetModuleGitlabOutput { +func (o GetStacksStackBitbucketCloudOutput) ToGetStacksStackBitbucketCloudOutputWithContext(ctx context.Context) GetStacksStackBitbucketCloudOutput { return o } -func (o GetModuleGitlabOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetModuleGitlab) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStackBitbucketCloudOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackBitbucketCloud] { + return pulumix.Output[GetStacksStackBitbucketCloud]{ + OutputState: o.OutputState, + } } -type GetModuleGitlabArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackBitbucketCloudOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackBitbucketCloud) string { return v.Namespace }).(pulumi.StringOutput) +} -func (GetModuleGitlabArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetModuleGitlab)(nil)).Elem() +type GetStacksStackBitbucketCloudArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackBitbucketCloudArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackBitbucketCloud)(nil)).Elem() } -func (o GetModuleGitlabArrayOutput) ToGetModuleGitlabArrayOutput() GetModuleGitlabArrayOutput { +func (o GetStacksStackBitbucketCloudArrayOutput) ToGetStacksStackBitbucketCloudArrayOutput() GetStacksStackBitbucketCloudArrayOutput { return o } -func (o GetModuleGitlabArrayOutput) ToGetModuleGitlabArrayOutputWithContext(ctx context.Context) GetModuleGitlabArrayOutput { +func (o GetStacksStackBitbucketCloudArrayOutput) ToGetStacksStackBitbucketCloudArrayOutputWithContext(ctx context.Context) GetStacksStackBitbucketCloudArrayOutput { return o } -func (o GetModuleGitlabArrayOutput) Index(i pulumi.IntInput) GetModuleGitlabOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetModuleGitlab { - return vs[0].([]GetModuleGitlab)[vs[1].(int)] - }).(GetModuleGitlabOutput) +func (o GetStacksStackBitbucketCloudArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackBitbucketCloud] { + return pulumix.Output[[]GetStacksStackBitbucketCloud]{ + OutputState: o.OutputState, + } } -type GetPoliciesPolicy struct { - // The ID of this resource. - Id string `pulumi:"id"` - // required labels to match - Labels []string `pulumi:"labels"` - Name string `pulumi:"name"` - SpaceId string `pulumi:"spaceId"` - // required policy type - Type string `pulumi:"type"` +func (o GetStacksStackBitbucketCloudArrayOutput) Index(i pulumi.IntInput) GetStacksStackBitbucketCloudOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackBitbucketCloud { + return vs[0].([]GetStacksStackBitbucketCloud)[vs[1].(int)] + }).(GetStacksStackBitbucketCloudOutput) } -// GetPoliciesPolicyInput is an input type that accepts GetPoliciesPolicyArgs and GetPoliciesPolicyOutput values. -// You can construct a concrete instance of `GetPoliciesPolicyInput` via: +type GetStacksStackBitbucketDatacenter struct { + Namespace string `pulumi:"namespace"` +} + +// GetStacksStackBitbucketDatacenterInput is an input type that accepts GetStacksStackBitbucketDatacenterArgs and GetStacksStackBitbucketDatacenterOutput values. +// You can construct a concrete instance of `GetStacksStackBitbucketDatacenterInput` via: // -// GetPoliciesPolicyArgs{...} -type GetPoliciesPolicyInput interface { +// GetStacksStackBitbucketDatacenterArgs{...} +type GetStacksStackBitbucketDatacenterInput interface { pulumi.Input - ToGetPoliciesPolicyOutput() GetPoliciesPolicyOutput - ToGetPoliciesPolicyOutputWithContext(context.Context) GetPoliciesPolicyOutput + ToGetStacksStackBitbucketDatacenterOutput() GetStacksStackBitbucketDatacenterOutput + ToGetStacksStackBitbucketDatacenterOutputWithContext(context.Context) GetStacksStackBitbucketDatacenterOutput } -type GetPoliciesPolicyArgs struct { - // The ID of this resource. - Id pulumi.StringInput `pulumi:"id"` - // required labels to match - Labels pulumi.StringArrayInput `pulumi:"labels"` - Name pulumi.StringInput `pulumi:"name"` - SpaceId pulumi.StringInput `pulumi:"spaceId"` - // required policy type - Type pulumi.StringInput `pulumi:"type"` +type GetStacksStackBitbucketDatacenterArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` } -func (GetPoliciesPolicyArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetPoliciesPolicy)(nil)).Elem() +func (GetStacksStackBitbucketDatacenterArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackBitbucketDatacenter)(nil)).Elem() } -func (i GetPoliciesPolicyArgs) ToGetPoliciesPolicyOutput() GetPoliciesPolicyOutput { - return i.ToGetPoliciesPolicyOutputWithContext(context.Background()) +func (i GetStacksStackBitbucketDatacenterArgs) ToGetStacksStackBitbucketDatacenterOutput() GetStacksStackBitbucketDatacenterOutput { + return i.ToGetStacksStackBitbucketDatacenterOutputWithContext(context.Background()) } -func (i GetPoliciesPolicyArgs) ToGetPoliciesPolicyOutputWithContext(ctx context.Context) GetPoliciesPolicyOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetPoliciesPolicyOutput) +func (i GetStacksStackBitbucketDatacenterArgs) ToGetStacksStackBitbucketDatacenterOutputWithContext(ctx context.Context) GetStacksStackBitbucketDatacenterOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackBitbucketDatacenterOutput) } -// GetPoliciesPolicyArrayInput is an input type that accepts GetPoliciesPolicyArray and GetPoliciesPolicyArrayOutput values. -// You can construct a concrete instance of `GetPoliciesPolicyArrayInput` via: +func (i GetStacksStackBitbucketDatacenterArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackBitbucketDatacenter] { + return pulumix.Output[GetStacksStackBitbucketDatacenter]{ + OutputState: i.ToGetStacksStackBitbucketDatacenterOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackBitbucketDatacenterArrayInput is an input type that accepts GetStacksStackBitbucketDatacenterArray and GetStacksStackBitbucketDatacenterArrayOutput values. +// You can construct a concrete instance of `GetStacksStackBitbucketDatacenterArrayInput` via: // -// GetPoliciesPolicyArray{ GetPoliciesPolicyArgs{...} } -type GetPoliciesPolicyArrayInput interface { +// GetStacksStackBitbucketDatacenterArray{ GetStacksStackBitbucketDatacenterArgs{...} } +type GetStacksStackBitbucketDatacenterArrayInput interface { pulumi.Input - ToGetPoliciesPolicyArrayOutput() GetPoliciesPolicyArrayOutput - ToGetPoliciesPolicyArrayOutputWithContext(context.Context) GetPoliciesPolicyArrayOutput + ToGetStacksStackBitbucketDatacenterArrayOutput() GetStacksStackBitbucketDatacenterArrayOutput + ToGetStacksStackBitbucketDatacenterArrayOutputWithContext(context.Context) GetStacksStackBitbucketDatacenterArrayOutput } -type GetPoliciesPolicyArray []GetPoliciesPolicyInput +type GetStacksStackBitbucketDatacenterArray []GetStacksStackBitbucketDatacenterInput -func (GetPoliciesPolicyArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetPoliciesPolicy)(nil)).Elem() +func (GetStacksStackBitbucketDatacenterArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackBitbucketDatacenter)(nil)).Elem() } -func (i GetPoliciesPolicyArray) ToGetPoliciesPolicyArrayOutput() GetPoliciesPolicyArrayOutput { - return i.ToGetPoliciesPolicyArrayOutputWithContext(context.Background()) +func (i GetStacksStackBitbucketDatacenterArray) ToGetStacksStackBitbucketDatacenterArrayOutput() GetStacksStackBitbucketDatacenterArrayOutput { + return i.ToGetStacksStackBitbucketDatacenterArrayOutputWithContext(context.Background()) } -func (i GetPoliciesPolicyArray) ToGetPoliciesPolicyArrayOutputWithContext(ctx context.Context) GetPoliciesPolicyArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetPoliciesPolicyArrayOutput) +func (i GetStacksStackBitbucketDatacenterArray) ToGetStacksStackBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetStacksStackBitbucketDatacenterArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackBitbucketDatacenterArrayOutput) } -type GetPoliciesPolicyOutput struct{ *pulumi.OutputState } - -func (GetPoliciesPolicyOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetPoliciesPolicy)(nil)).Elem() +func (i GetStacksStackBitbucketDatacenterArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackBitbucketDatacenter] { + return pulumix.Output[[]GetStacksStackBitbucketDatacenter]{ + OutputState: i.ToGetStacksStackBitbucketDatacenterArrayOutputWithContext(ctx).OutputState, + } } -func (o GetPoliciesPolicyOutput) ToGetPoliciesPolicyOutput() GetPoliciesPolicyOutput { - return o +type GetStacksStackBitbucketDatacenterOutput struct{ *pulumi.OutputState } + +func (GetStacksStackBitbucketDatacenterOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackBitbucketDatacenter)(nil)).Elem() } -func (o GetPoliciesPolicyOutput) ToGetPoliciesPolicyOutputWithContext(ctx context.Context) GetPoliciesPolicyOutput { +func (o GetStacksStackBitbucketDatacenterOutput) ToGetStacksStackBitbucketDatacenterOutput() GetStacksStackBitbucketDatacenterOutput { return o } -// The ID of this resource. -func (o GetPoliciesPolicyOutput) Id() pulumi.StringOutput { - return o.ApplyT(func(v GetPoliciesPolicy) string { return v.Id }).(pulumi.StringOutput) +func (o GetStacksStackBitbucketDatacenterOutput) ToGetStacksStackBitbucketDatacenterOutputWithContext(ctx context.Context) GetStacksStackBitbucketDatacenterOutput { + return o } -// required labels to match -func (o GetPoliciesPolicyOutput) Labels() pulumi.StringArrayOutput { - return o.ApplyT(func(v GetPoliciesPolicy) []string { return v.Labels }).(pulumi.StringArrayOutput) +func (o GetStacksStackBitbucketDatacenterOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackBitbucketDatacenter] { + return pulumix.Output[GetStacksStackBitbucketDatacenter]{ + OutputState: o.OutputState, + } } -func (o GetPoliciesPolicyOutput) Name() pulumi.StringOutput { - return o.ApplyT(func(v GetPoliciesPolicy) string { return v.Name }).(pulumi.StringOutput) +func (o GetStacksStackBitbucketDatacenterOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackBitbucketDatacenter) string { return v.Namespace }).(pulumi.StringOutput) } -func (o GetPoliciesPolicyOutput) SpaceId() pulumi.StringOutput { - return o.ApplyT(func(v GetPoliciesPolicy) string { return v.SpaceId }).(pulumi.StringOutput) -} +type GetStacksStackBitbucketDatacenterArrayOutput struct{ *pulumi.OutputState } -// required policy type -func (o GetPoliciesPolicyOutput) Type() pulumi.StringOutput { - return o.ApplyT(func(v GetPoliciesPolicy) string { return v.Type }).(pulumi.StringOutput) +func (GetStacksStackBitbucketDatacenterArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackBitbucketDatacenter)(nil)).Elem() } -type GetPoliciesPolicyArrayOutput struct{ *pulumi.OutputState } - -func (GetPoliciesPolicyArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetPoliciesPolicy)(nil)).Elem() +func (o GetStacksStackBitbucketDatacenterArrayOutput) ToGetStacksStackBitbucketDatacenterArrayOutput() GetStacksStackBitbucketDatacenterArrayOutput { + return o } -func (o GetPoliciesPolicyArrayOutput) ToGetPoliciesPolicyArrayOutput() GetPoliciesPolicyArrayOutput { +func (o GetStacksStackBitbucketDatacenterArrayOutput) ToGetStacksStackBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetStacksStackBitbucketDatacenterArrayOutput { return o } -func (o GetPoliciesPolicyArrayOutput) ToGetPoliciesPolicyArrayOutputWithContext(ctx context.Context) GetPoliciesPolicyArrayOutput { - return o +func (o GetStacksStackBitbucketDatacenterArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackBitbucketDatacenter] { + return pulumix.Output[[]GetStacksStackBitbucketDatacenter]{ + OutputState: o.OutputState, + } } -func (o GetPoliciesPolicyArrayOutput) Index(i pulumi.IntInput) GetPoliciesPolicyOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoliciesPolicy { - return vs[0].([]GetPoliciesPolicy)[vs[1].(int)] - }).(GetPoliciesPolicyOutput) +func (o GetStacksStackBitbucketDatacenterArrayOutput) Index(i pulumi.IntInput) GetStacksStackBitbucketDatacenterOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackBitbucketDatacenter { + return vs[0].([]GetStacksStackBitbucketDatacenter)[vs[1].(int)] + }).(GetStacksStackBitbucketDatacenterOutput) } -type GetStackAnsible struct { - Playbook string `pulumi:"playbook"` +type GetStacksStackCloudformation struct { + EntryTemplateFile string `pulumi:"entryTemplateFile"` + Region string `pulumi:"region"` + StackName string `pulumi:"stackName"` + TemplateBucket string `pulumi:"templateBucket"` } -// GetStackAnsibleInput is an input type that accepts GetStackAnsibleArgs and GetStackAnsibleOutput values. -// You can construct a concrete instance of `GetStackAnsibleInput` via: +// GetStacksStackCloudformationInput is an input type that accepts GetStacksStackCloudformationArgs and GetStacksStackCloudformationOutput values. +// You can construct a concrete instance of `GetStacksStackCloudformationInput` via: // -// GetStackAnsibleArgs{...} -type GetStackAnsibleInput interface { +// GetStacksStackCloudformationArgs{...} +type GetStacksStackCloudformationInput interface { pulumi.Input - ToGetStackAnsibleOutput() GetStackAnsibleOutput - ToGetStackAnsibleOutputWithContext(context.Context) GetStackAnsibleOutput + ToGetStacksStackCloudformationOutput() GetStacksStackCloudformationOutput + ToGetStacksStackCloudformationOutputWithContext(context.Context) GetStacksStackCloudformationOutput } -type GetStackAnsibleArgs struct { - Playbook pulumi.StringInput `pulumi:"playbook"` +type GetStacksStackCloudformationArgs struct { + EntryTemplateFile pulumi.StringInput `pulumi:"entryTemplateFile"` + Region pulumi.StringInput `pulumi:"region"` + StackName pulumi.StringInput `pulumi:"stackName"` + TemplateBucket pulumi.StringInput `pulumi:"templateBucket"` } -func (GetStackAnsibleArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackAnsible)(nil)).Elem() +func (GetStacksStackCloudformationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackCloudformation)(nil)).Elem() } -func (i GetStackAnsibleArgs) ToGetStackAnsibleOutput() GetStackAnsibleOutput { - return i.ToGetStackAnsibleOutputWithContext(context.Background()) +func (i GetStacksStackCloudformationArgs) ToGetStacksStackCloudformationOutput() GetStacksStackCloudformationOutput { + return i.ToGetStacksStackCloudformationOutputWithContext(context.Background()) } -func (i GetStackAnsibleArgs) ToGetStackAnsibleOutputWithContext(ctx context.Context) GetStackAnsibleOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackAnsibleOutput) +func (i GetStacksStackCloudformationArgs) ToGetStacksStackCloudformationOutputWithContext(ctx context.Context) GetStacksStackCloudformationOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackCloudformationOutput) } -// GetStackAnsibleArrayInput is an input type that accepts GetStackAnsibleArray and GetStackAnsibleArrayOutput values. -// You can construct a concrete instance of `GetStackAnsibleArrayInput` via: +func (i GetStacksStackCloudformationArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackCloudformation] { + return pulumix.Output[GetStacksStackCloudformation]{ + OutputState: i.ToGetStacksStackCloudformationOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackCloudformationArrayInput is an input type that accepts GetStacksStackCloudformationArray and GetStacksStackCloudformationArrayOutput values. +// You can construct a concrete instance of `GetStacksStackCloudformationArrayInput` via: // -// GetStackAnsibleArray{ GetStackAnsibleArgs{...} } -type GetStackAnsibleArrayInput interface { +// GetStacksStackCloudformationArray{ GetStacksStackCloudformationArgs{...} } +type GetStacksStackCloudformationArrayInput interface { pulumi.Input - ToGetStackAnsibleArrayOutput() GetStackAnsibleArrayOutput - ToGetStackAnsibleArrayOutputWithContext(context.Context) GetStackAnsibleArrayOutput + ToGetStacksStackCloudformationArrayOutput() GetStacksStackCloudformationArrayOutput + ToGetStacksStackCloudformationArrayOutputWithContext(context.Context) GetStacksStackCloudformationArrayOutput } -type GetStackAnsibleArray []GetStackAnsibleInput +type GetStacksStackCloudformationArray []GetStacksStackCloudformationInput -func (GetStackAnsibleArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackAnsible)(nil)).Elem() +func (GetStacksStackCloudformationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackCloudformation)(nil)).Elem() } -func (i GetStackAnsibleArray) ToGetStackAnsibleArrayOutput() GetStackAnsibleArrayOutput { - return i.ToGetStackAnsibleArrayOutputWithContext(context.Background()) +func (i GetStacksStackCloudformationArray) ToGetStacksStackCloudformationArrayOutput() GetStacksStackCloudformationArrayOutput { + return i.ToGetStacksStackCloudformationArrayOutputWithContext(context.Background()) } -func (i GetStackAnsibleArray) ToGetStackAnsibleArrayOutputWithContext(ctx context.Context) GetStackAnsibleArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackAnsibleArrayOutput) +func (i GetStacksStackCloudformationArray) ToGetStacksStackCloudformationArrayOutputWithContext(ctx context.Context) GetStacksStackCloudformationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackCloudformationArrayOutput) } -type GetStackAnsibleOutput struct{ *pulumi.OutputState } +func (i GetStacksStackCloudformationArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackCloudformation] { + return pulumix.Output[[]GetStacksStackCloudformation]{ + OutputState: i.ToGetStacksStackCloudformationArrayOutputWithContext(ctx).OutputState, + } +} -func (GetStackAnsibleOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackAnsible)(nil)).Elem() +type GetStacksStackCloudformationOutput struct{ *pulumi.OutputState } + +func (GetStacksStackCloudformationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackCloudformation)(nil)).Elem() } -func (o GetStackAnsibleOutput) ToGetStackAnsibleOutput() GetStackAnsibleOutput { +func (o GetStacksStackCloudformationOutput) ToGetStacksStackCloudformationOutput() GetStacksStackCloudformationOutput { return o } -func (o GetStackAnsibleOutput) ToGetStackAnsibleOutputWithContext(ctx context.Context) GetStackAnsibleOutput { +func (o GetStacksStackCloudformationOutput) ToGetStacksStackCloudformationOutputWithContext(ctx context.Context) GetStacksStackCloudformationOutput { return o } -func (o GetStackAnsibleOutput) Playbook() pulumi.StringOutput { - return o.ApplyT(func(v GetStackAnsible) string { return v.Playbook }).(pulumi.StringOutput) +func (o GetStacksStackCloudformationOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackCloudformation] { + return pulumix.Output[GetStacksStackCloudformation]{ + OutputState: o.OutputState, + } } -type GetStackAnsibleArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackCloudformationOutput) EntryTemplateFile() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackCloudformation) string { return v.EntryTemplateFile }).(pulumi.StringOutput) +} -func (GetStackAnsibleArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackAnsible)(nil)).Elem() +func (o GetStacksStackCloudformationOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackCloudformation) string { return v.Region }).(pulumi.StringOutput) } -func (o GetStackAnsibleArrayOutput) ToGetStackAnsibleArrayOutput() GetStackAnsibleArrayOutput { +func (o GetStacksStackCloudformationOutput) StackName() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackCloudformation) string { return v.StackName }).(pulumi.StringOutput) +} + +func (o GetStacksStackCloudformationOutput) TemplateBucket() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackCloudformation) string { return v.TemplateBucket }).(pulumi.StringOutput) +} + +type GetStacksStackCloudformationArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackCloudformationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackCloudformation)(nil)).Elem() +} + +func (o GetStacksStackCloudformationArrayOutput) ToGetStacksStackCloudformationArrayOutput() GetStacksStackCloudformationArrayOutput { return o } -func (o GetStackAnsibleArrayOutput) ToGetStackAnsibleArrayOutputWithContext(ctx context.Context) GetStackAnsibleArrayOutput { +func (o GetStacksStackCloudformationArrayOutput) ToGetStacksStackCloudformationArrayOutputWithContext(ctx context.Context) GetStacksStackCloudformationArrayOutput { return o } -func (o GetStackAnsibleArrayOutput) Index(i pulumi.IntInput) GetStackAnsibleOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackAnsible { - return vs[0].([]GetStackAnsible)[vs[1].(int)] - }).(GetStackAnsibleOutput) +func (o GetStacksStackCloudformationArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackCloudformation] { + return pulumix.Output[[]GetStacksStackCloudformation]{ + OutputState: o.OutputState, + } } -type GetStackAzureDevop struct { - Project string `pulumi:"project"` +func (o GetStacksStackCloudformationArrayOutput) Index(i pulumi.IntInput) GetStacksStackCloudformationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackCloudformation { + return vs[0].([]GetStacksStackCloudformation)[vs[1].(int)] + }).(GetStacksStackCloudformationOutput) } -// GetStackAzureDevopInput is an input type that accepts GetStackAzureDevopArgs and GetStackAzureDevopOutput values. -// You can construct a concrete instance of `GetStackAzureDevopInput` via: +type GetStacksStackGithubEnterprise struct { + Namespace string `pulumi:"namespace"` +} + +// GetStacksStackGithubEnterpriseInput is an input type that accepts GetStacksStackGithubEnterpriseArgs and GetStacksStackGithubEnterpriseOutput values. +// You can construct a concrete instance of `GetStacksStackGithubEnterpriseInput` via: // -// GetStackAzureDevopArgs{...} -type GetStackAzureDevopInput interface { +// GetStacksStackGithubEnterpriseArgs{...} +type GetStacksStackGithubEnterpriseInput interface { pulumi.Input - ToGetStackAzureDevopOutput() GetStackAzureDevopOutput - ToGetStackAzureDevopOutputWithContext(context.Context) GetStackAzureDevopOutput + ToGetStacksStackGithubEnterpriseOutput() GetStacksStackGithubEnterpriseOutput + ToGetStacksStackGithubEnterpriseOutputWithContext(context.Context) GetStacksStackGithubEnterpriseOutput } -type GetStackAzureDevopArgs struct { - Project pulumi.StringInput `pulumi:"project"` +type GetStacksStackGithubEnterpriseArgs struct { + Namespace pulumi.StringInput `pulumi:"namespace"` } -func (GetStackAzureDevopArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackAzureDevop)(nil)).Elem() +func (GetStacksStackGithubEnterpriseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackGithubEnterprise)(nil)).Elem() } -func (i GetStackAzureDevopArgs) ToGetStackAzureDevopOutput() GetStackAzureDevopOutput { - return i.ToGetStackAzureDevopOutputWithContext(context.Background()) +func (i GetStacksStackGithubEnterpriseArgs) ToGetStacksStackGithubEnterpriseOutput() GetStacksStackGithubEnterpriseOutput { + return i.ToGetStacksStackGithubEnterpriseOutputWithContext(context.Background()) } -func (i GetStackAzureDevopArgs) ToGetStackAzureDevopOutputWithContext(ctx context.Context) GetStackAzureDevopOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackAzureDevopOutput) +func (i GetStacksStackGithubEnterpriseArgs) ToGetStacksStackGithubEnterpriseOutputWithContext(ctx context.Context) GetStacksStackGithubEnterpriseOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackGithubEnterpriseOutput) } -// GetStackAzureDevopArrayInput is an input type that accepts GetStackAzureDevopArray and GetStackAzureDevopArrayOutput values. -// You can construct a concrete instance of `GetStackAzureDevopArrayInput` via: +func (i GetStacksStackGithubEnterpriseArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackGithubEnterprise] { + return pulumix.Output[GetStacksStackGithubEnterprise]{ + OutputState: i.ToGetStacksStackGithubEnterpriseOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackGithubEnterpriseArrayInput is an input type that accepts GetStacksStackGithubEnterpriseArray and GetStacksStackGithubEnterpriseArrayOutput values. +// You can construct a concrete instance of `GetStacksStackGithubEnterpriseArrayInput` via: // -// GetStackAzureDevopArray{ GetStackAzureDevopArgs{...} } -type GetStackAzureDevopArrayInput interface { +// GetStacksStackGithubEnterpriseArray{ GetStacksStackGithubEnterpriseArgs{...} } +type GetStacksStackGithubEnterpriseArrayInput interface { pulumi.Input - ToGetStackAzureDevopArrayOutput() GetStackAzureDevopArrayOutput - ToGetStackAzureDevopArrayOutputWithContext(context.Context) GetStackAzureDevopArrayOutput + ToGetStacksStackGithubEnterpriseArrayOutput() GetStacksStackGithubEnterpriseArrayOutput + ToGetStacksStackGithubEnterpriseArrayOutputWithContext(context.Context) GetStacksStackGithubEnterpriseArrayOutput } -type GetStackAzureDevopArray []GetStackAzureDevopInput +type GetStacksStackGithubEnterpriseArray []GetStacksStackGithubEnterpriseInput -func (GetStackAzureDevopArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackAzureDevop)(nil)).Elem() +func (GetStacksStackGithubEnterpriseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackGithubEnterprise)(nil)).Elem() } -func (i GetStackAzureDevopArray) ToGetStackAzureDevopArrayOutput() GetStackAzureDevopArrayOutput { - return i.ToGetStackAzureDevopArrayOutputWithContext(context.Background()) +func (i GetStacksStackGithubEnterpriseArray) ToGetStacksStackGithubEnterpriseArrayOutput() GetStacksStackGithubEnterpriseArrayOutput { + return i.ToGetStacksStackGithubEnterpriseArrayOutputWithContext(context.Background()) } -func (i GetStackAzureDevopArray) ToGetStackAzureDevopArrayOutputWithContext(ctx context.Context) GetStackAzureDevopArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackAzureDevopArrayOutput) +func (i GetStacksStackGithubEnterpriseArray) ToGetStacksStackGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetStacksStackGithubEnterpriseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackGithubEnterpriseArrayOutput) } -type GetStackAzureDevopOutput struct{ *pulumi.OutputState } +func (i GetStacksStackGithubEnterpriseArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackGithubEnterprise] { + return pulumix.Output[[]GetStacksStackGithubEnterprise]{ + OutputState: i.ToGetStacksStackGithubEnterpriseArrayOutputWithContext(ctx).OutputState, + } +} -func (GetStackAzureDevopOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackAzureDevop)(nil)).Elem() +type GetStacksStackGithubEnterpriseOutput struct{ *pulumi.OutputState } + +func (GetStacksStackGithubEnterpriseOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackGithubEnterprise)(nil)).Elem() } -func (o GetStackAzureDevopOutput) ToGetStackAzureDevopOutput() GetStackAzureDevopOutput { +func (o GetStacksStackGithubEnterpriseOutput) ToGetStacksStackGithubEnterpriseOutput() GetStacksStackGithubEnterpriseOutput { return o } -func (o GetStackAzureDevopOutput) ToGetStackAzureDevopOutputWithContext(ctx context.Context) GetStackAzureDevopOutput { +func (o GetStacksStackGithubEnterpriseOutput) ToGetStacksStackGithubEnterpriseOutputWithContext(ctx context.Context) GetStacksStackGithubEnterpriseOutput { return o } -func (o GetStackAzureDevopOutput) Project() pulumi.StringOutput { - return o.ApplyT(func(v GetStackAzureDevop) string { return v.Project }).(pulumi.StringOutput) +func (o GetStacksStackGithubEnterpriseOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackGithubEnterprise] { + return pulumix.Output[GetStacksStackGithubEnterprise]{ + OutputState: o.OutputState, + } } -type GetStackAzureDevopArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackGithubEnterpriseOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackGithubEnterprise) string { return v.Namespace }).(pulumi.StringOutput) +} -func (GetStackAzureDevopArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackAzureDevop)(nil)).Elem() +type GetStacksStackGithubEnterpriseArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackGithubEnterpriseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackGithubEnterprise)(nil)).Elem() } -func (o GetStackAzureDevopArrayOutput) ToGetStackAzureDevopArrayOutput() GetStackAzureDevopArrayOutput { +func (o GetStacksStackGithubEnterpriseArrayOutput) ToGetStacksStackGithubEnterpriseArrayOutput() GetStacksStackGithubEnterpriseArrayOutput { return o } -func (o GetStackAzureDevopArrayOutput) ToGetStackAzureDevopArrayOutputWithContext(ctx context.Context) GetStackAzureDevopArrayOutput { +func (o GetStacksStackGithubEnterpriseArrayOutput) ToGetStacksStackGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetStacksStackGithubEnterpriseArrayOutput { return o } -func (o GetStackAzureDevopArrayOutput) Index(i pulumi.IntInput) GetStackAzureDevopOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackAzureDevop { - return vs[0].([]GetStackAzureDevop)[vs[1].(int)] - }).(GetStackAzureDevopOutput) +func (o GetStacksStackGithubEnterpriseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackGithubEnterprise] { + return pulumix.Output[[]GetStacksStackGithubEnterprise]{ + OutputState: o.OutputState, + } } -type GetStackBitbucketCloud struct { +func (o GetStacksStackGithubEnterpriseArrayOutput) Index(i pulumi.IntInput) GetStacksStackGithubEnterpriseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackGithubEnterprise { + return vs[0].([]GetStacksStackGithubEnterprise)[vs[1].(int)] + }).(GetStacksStackGithubEnterpriseOutput) +} + +type GetStacksStackGitlab struct { Namespace string `pulumi:"namespace"` } -// GetStackBitbucketCloudInput is an input type that accepts GetStackBitbucketCloudArgs and GetStackBitbucketCloudOutput values. -// You can construct a concrete instance of `GetStackBitbucketCloudInput` via: +// GetStacksStackGitlabInput is an input type that accepts GetStacksStackGitlabArgs and GetStacksStackGitlabOutput values. +// You can construct a concrete instance of `GetStacksStackGitlabInput` via: // -// GetStackBitbucketCloudArgs{...} -type GetStackBitbucketCloudInput interface { +// GetStacksStackGitlabArgs{...} +type GetStacksStackGitlabInput interface { pulumi.Input - ToGetStackBitbucketCloudOutput() GetStackBitbucketCloudOutput - ToGetStackBitbucketCloudOutputWithContext(context.Context) GetStackBitbucketCloudOutput + ToGetStacksStackGitlabOutput() GetStacksStackGitlabOutput + ToGetStacksStackGitlabOutputWithContext(context.Context) GetStacksStackGitlabOutput } -type GetStackBitbucketCloudArgs struct { +type GetStacksStackGitlabArgs struct { Namespace pulumi.StringInput `pulumi:"namespace"` } -func (GetStackBitbucketCloudArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackBitbucketCloud)(nil)).Elem() +func (GetStacksStackGitlabArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackGitlab)(nil)).Elem() } -func (i GetStackBitbucketCloudArgs) ToGetStackBitbucketCloudOutput() GetStackBitbucketCloudOutput { - return i.ToGetStackBitbucketCloudOutputWithContext(context.Background()) +func (i GetStacksStackGitlabArgs) ToGetStacksStackGitlabOutput() GetStacksStackGitlabOutput { + return i.ToGetStacksStackGitlabOutputWithContext(context.Background()) } -func (i GetStackBitbucketCloudArgs) ToGetStackBitbucketCloudOutputWithContext(ctx context.Context) GetStackBitbucketCloudOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackBitbucketCloudOutput) +func (i GetStacksStackGitlabArgs) ToGetStacksStackGitlabOutputWithContext(ctx context.Context) GetStacksStackGitlabOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackGitlabOutput) } -// GetStackBitbucketCloudArrayInput is an input type that accepts GetStackBitbucketCloudArray and GetStackBitbucketCloudArrayOutput values. -// You can construct a concrete instance of `GetStackBitbucketCloudArrayInput` via: +func (i GetStacksStackGitlabArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackGitlab] { + return pulumix.Output[GetStacksStackGitlab]{ + OutputState: i.ToGetStacksStackGitlabOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackGitlabArrayInput is an input type that accepts GetStacksStackGitlabArray and GetStacksStackGitlabArrayOutput values. +// You can construct a concrete instance of `GetStacksStackGitlabArrayInput` via: // -// GetStackBitbucketCloudArray{ GetStackBitbucketCloudArgs{...} } -type GetStackBitbucketCloudArrayInput interface { +// GetStacksStackGitlabArray{ GetStacksStackGitlabArgs{...} } +type GetStacksStackGitlabArrayInput interface { pulumi.Input - ToGetStackBitbucketCloudArrayOutput() GetStackBitbucketCloudArrayOutput - ToGetStackBitbucketCloudArrayOutputWithContext(context.Context) GetStackBitbucketCloudArrayOutput + ToGetStacksStackGitlabArrayOutput() GetStacksStackGitlabArrayOutput + ToGetStacksStackGitlabArrayOutputWithContext(context.Context) GetStacksStackGitlabArrayOutput } -type GetStackBitbucketCloudArray []GetStackBitbucketCloudInput +type GetStacksStackGitlabArray []GetStacksStackGitlabInput -func (GetStackBitbucketCloudArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackBitbucketCloud)(nil)).Elem() +func (GetStacksStackGitlabArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackGitlab)(nil)).Elem() } -func (i GetStackBitbucketCloudArray) ToGetStackBitbucketCloudArrayOutput() GetStackBitbucketCloudArrayOutput { - return i.ToGetStackBitbucketCloudArrayOutputWithContext(context.Background()) +func (i GetStacksStackGitlabArray) ToGetStacksStackGitlabArrayOutput() GetStacksStackGitlabArrayOutput { + return i.ToGetStacksStackGitlabArrayOutputWithContext(context.Background()) } -func (i GetStackBitbucketCloudArray) ToGetStackBitbucketCloudArrayOutputWithContext(ctx context.Context) GetStackBitbucketCloudArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackBitbucketCloudArrayOutput) +func (i GetStacksStackGitlabArray) ToGetStacksStackGitlabArrayOutputWithContext(ctx context.Context) GetStacksStackGitlabArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackGitlabArrayOutput) } -type GetStackBitbucketCloudOutput struct{ *pulumi.OutputState } +func (i GetStacksStackGitlabArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackGitlab] { + return pulumix.Output[[]GetStacksStackGitlab]{ + OutputState: i.ToGetStacksStackGitlabArrayOutputWithContext(ctx).OutputState, + } +} -func (GetStackBitbucketCloudOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackBitbucketCloud)(nil)).Elem() +type GetStacksStackGitlabOutput struct{ *pulumi.OutputState } + +func (GetStacksStackGitlabOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackGitlab)(nil)).Elem() } -func (o GetStackBitbucketCloudOutput) ToGetStackBitbucketCloudOutput() GetStackBitbucketCloudOutput { +func (o GetStacksStackGitlabOutput) ToGetStacksStackGitlabOutput() GetStacksStackGitlabOutput { return o } -func (o GetStackBitbucketCloudOutput) ToGetStackBitbucketCloudOutputWithContext(ctx context.Context) GetStackBitbucketCloudOutput { +func (o GetStacksStackGitlabOutput) ToGetStacksStackGitlabOutputWithContext(ctx context.Context) GetStacksStackGitlabOutput { return o } -func (o GetStackBitbucketCloudOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetStackBitbucketCloud) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStackGitlabOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackGitlab] { + return pulumix.Output[GetStacksStackGitlab]{ + OutputState: o.OutputState, + } } -type GetStackBitbucketCloudArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackGitlabOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackGitlab) string { return v.Namespace }).(pulumi.StringOutput) +} -func (GetStackBitbucketCloudArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackBitbucketCloud)(nil)).Elem() +type GetStacksStackGitlabArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackGitlabArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackGitlab)(nil)).Elem() } -func (o GetStackBitbucketCloudArrayOutput) ToGetStackBitbucketCloudArrayOutput() GetStackBitbucketCloudArrayOutput { +func (o GetStacksStackGitlabArrayOutput) ToGetStacksStackGitlabArrayOutput() GetStacksStackGitlabArrayOutput { return o } -func (o GetStackBitbucketCloudArrayOutput) ToGetStackBitbucketCloudArrayOutputWithContext(ctx context.Context) GetStackBitbucketCloudArrayOutput { +func (o GetStacksStackGitlabArrayOutput) ToGetStacksStackGitlabArrayOutputWithContext(ctx context.Context) GetStacksStackGitlabArrayOutput { return o } -func (o GetStackBitbucketCloudArrayOutput) Index(i pulumi.IntInput) GetStackBitbucketCloudOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackBitbucketCloud { - return vs[0].([]GetStackBitbucketCloud)[vs[1].(int)] - }).(GetStackBitbucketCloudOutput) +func (o GetStacksStackGitlabArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackGitlab] { + return pulumix.Output[[]GetStacksStackGitlab]{ + OutputState: o.OutputState, + } } -type GetStackBitbucketDatacenter struct { - Namespace string `pulumi:"namespace"` +func (o GetStacksStackGitlabArrayOutput) Index(i pulumi.IntInput) GetStacksStackGitlabOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackGitlab { + return vs[0].([]GetStacksStackGitlab)[vs[1].(int)] + }).(GetStacksStackGitlabOutput) } -// GetStackBitbucketDatacenterInput is an input type that accepts GetStackBitbucketDatacenterArgs and GetStackBitbucketDatacenterOutput values. -// You can construct a concrete instance of `GetStackBitbucketDatacenterInput` via: +type GetStacksStackKubernete struct { + KubectlVersion string `pulumi:"kubectlVersion"` + Namespace string `pulumi:"namespace"` +} + +// GetStacksStackKuberneteInput is an input type that accepts GetStacksStackKuberneteArgs and GetStacksStackKuberneteOutput values. +// You can construct a concrete instance of `GetStacksStackKuberneteInput` via: // -// GetStackBitbucketDatacenterArgs{...} -type GetStackBitbucketDatacenterInput interface { +// GetStacksStackKuberneteArgs{...} +type GetStacksStackKuberneteInput interface { pulumi.Input - ToGetStackBitbucketDatacenterOutput() GetStackBitbucketDatacenterOutput - ToGetStackBitbucketDatacenterOutputWithContext(context.Context) GetStackBitbucketDatacenterOutput + ToGetStacksStackKuberneteOutput() GetStacksStackKuberneteOutput + ToGetStacksStackKuberneteOutputWithContext(context.Context) GetStacksStackKuberneteOutput } -type GetStackBitbucketDatacenterArgs struct { - Namespace pulumi.StringInput `pulumi:"namespace"` +type GetStacksStackKuberneteArgs struct { + KubectlVersion pulumi.StringInput `pulumi:"kubectlVersion"` + Namespace pulumi.StringInput `pulumi:"namespace"` } -func (GetStackBitbucketDatacenterArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackBitbucketDatacenter)(nil)).Elem() +func (GetStacksStackKuberneteArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackKubernete)(nil)).Elem() } -func (i GetStackBitbucketDatacenterArgs) ToGetStackBitbucketDatacenterOutput() GetStackBitbucketDatacenterOutput { - return i.ToGetStackBitbucketDatacenterOutputWithContext(context.Background()) +func (i GetStacksStackKuberneteArgs) ToGetStacksStackKuberneteOutput() GetStacksStackKuberneteOutput { + return i.ToGetStacksStackKuberneteOutputWithContext(context.Background()) } -func (i GetStackBitbucketDatacenterArgs) ToGetStackBitbucketDatacenterOutputWithContext(ctx context.Context) GetStackBitbucketDatacenterOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackBitbucketDatacenterOutput) +func (i GetStacksStackKuberneteArgs) ToGetStacksStackKuberneteOutputWithContext(ctx context.Context) GetStacksStackKuberneteOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackKuberneteOutput) } -// GetStackBitbucketDatacenterArrayInput is an input type that accepts GetStackBitbucketDatacenterArray and GetStackBitbucketDatacenterArrayOutput values. -// You can construct a concrete instance of `GetStackBitbucketDatacenterArrayInput` via: +func (i GetStacksStackKuberneteArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackKubernete] { + return pulumix.Output[GetStacksStackKubernete]{ + OutputState: i.ToGetStacksStackKuberneteOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackKuberneteArrayInput is an input type that accepts GetStacksStackKuberneteArray and GetStacksStackKuberneteArrayOutput values. +// You can construct a concrete instance of `GetStacksStackKuberneteArrayInput` via: // -// GetStackBitbucketDatacenterArray{ GetStackBitbucketDatacenterArgs{...} } -type GetStackBitbucketDatacenterArrayInput interface { +// GetStacksStackKuberneteArray{ GetStacksStackKuberneteArgs{...} } +type GetStacksStackKuberneteArrayInput interface { pulumi.Input - ToGetStackBitbucketDatacenterArrayOutput() GetStackBitbucketDatacenterArrayOutput - ToGetStackBitbucketDatacenterArrayOutputWithContext(context.Context) GetStackBitbucketDatacenterArrayOutput + ToGetStacksStackKuberneteArrayOutput() GetStacksStackKuberneteArrayOutput + ToGetStacksStackKuberneteArrayOutputWithContext(context.Context) GetStacksStackKuberneteArrayOutput } -type GetStackBitbucketDatacenterArray []GetStackBitbucketDatacenterInput +type GetStacksStackKuberneteArray []GetStacksStackKuberneteInput -func (GetStackBitbucketDatacenterArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackBitbucketDatacenter)(nil)).Elem() +func (GetStacksStackKuberneteArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackKubernete)(nil)).Elem() } -func (i GetStackBitbucketDatacenterArray) ToGetStackBitbucketDatacenterArrayOutput() GetStackBitbucketDatacenterArrayOutput { - return i.ToGetStackBitbucketDatacenterArrayOutputWithContext(context.Background()) +func (i GetStacksStackKuberneteArray) ToGetStacksStackKuberneteArrayOutput() GetStacksStackKuberneteArrayOutput { + return i.ToGetStacksStackKuberneteArrayOutputWithContext(context.Background()) } -func (i GetStackBitbucketDatacenterArray) ToGetStackBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetStackBitbucketDatacenterArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackBitbucketDatacenterArrayOutput) +func (i GetStacksStackKuberneteArray) ToGetStacksStackKuberneteArrayOutputWithContext(ctx context.Context) GetStacksStackKuberneteArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackKuberneteArrayOutput) } -type GetStackBitbucketDatacenterOutput struct{ *pulumi.OutputState } +func (i GetStacksStackKuberneteArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackKubernete] { + return pulumix.Output[[]GetStacksStackKubernete]{ + OutputState: i.ToGetStacksStackKuberneteArrayOutputWithContext(ctx).OutputState, + } +} -func (GetStackBitbucketDatacenterOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackBitbucketDatacenter)(nil)).Elem() +type GetStacksStackKuberneteOutput struct{ *pulumi.OutputState } + +func (GetStacksStackKuberneteOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackKubernete)(nil)).Elem() } -func (o GetStackBitbucketDatacenterOutput) ToGetStackBitbucketDatacenterOutput() GetStackBitbucketDatacenterOutput { +func (o GetStacksStackKuberneteOutput) ToGetStacksStackKuberneteOutput() GetStacksStackKuberneteOutput { return o } -func (o GetStackBitbucketDatacenterOutput) ToGetStackBitbucketDatacenterOutputWithContext(ctx context.Context) GetStackBitbucketDatacenterOutput { +func (o GetStacksStackKuberneteOutput) ToGetStacksStackKuberneteOutputWithContext(ctx context.Context) GetStacksStackKuberneteOutput { return o } -func (o GetStackBitbucketDatacenterOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetStackBitbucketDatacenter) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStackKuberneteOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackKubernete] { + return pulumix.Output[GetStacksStackKubernete]{ + OutputState: o.OutputState, + } } -type GetStackBitbucketDatacenterArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackKuberneteOutput) KubectlVersion() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackKubernete) string { return v.KubectlVersion }).(pulumi.StringOutput) +} -func (GetStackBitbucketDatacenterArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackBitbucketDatacenter)(nil)).Elem() +func (o GetStacksStackKuberneteOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackKubernete) string { return v.Namespace }).(pulumi.StringOutput) } -func (o GetStackBitbucketDatacenterArrayOutput) ToGetStackBitbucketDatacenterArrayOutput() GetStackBitbucketDatacenterArrayOutput { +type GetStacksStackKuberneteArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackKuberneteArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackKubernete)(nil)).Elem() +} + +func (o GetStacksStackKuberneteArrayOutput) ToGetStacksStackKuberneteArrayOutput() GetStacksStackKuberneteArrayOutput { return o } -func (o GetStackBitbucketDatacenterArrayOutput) ToGetStackBitbucketDatacenterArrayOutputWithContext(ctx context.Context) GetStackBitbucketDatacenterArrayOutput { +func (o GetStacksStackKuberneteArrayOutput) ToGetStacksStackKuberneteArrayOutputWithContext(ctx context.Context) GetStacksStackKuberneteArrayOutput { return o } -func (o GetStackBitbucketDatacenterArrayOutput) Index(i pulumi.IntInput) GetStackBitbucketDatacenterOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackBitbucketDatacenter { - return vs[0].([]GetStackBitbucketDatacenter)[vs[1].(int)] - }).(GetStackBitbucketDatacenterOutput) +func (o GetStacksStackKuberneteArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackKubernete] { + return pulumix.Output[[]GetStacksStackKubernete]{ + OutputState: o.OutputState, + } } -type GetStackCloudformation struct { - EntryTemplateFile string `pulumi:"entryTemplateFile"` - Region string `pulumi:"region"` - StackName string `pulumi:"stackName"` - TemplateBucket string `pulumi:"templateBucket"` +func (o GetStacksStackKuberneteArrayOutput) Index(i pulumi.IntInput) GetStacksStackKuberneteOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackKubernete { + return vs[0].([]GetStacksStackKubernete)[vs[1].(int)] + }).(GetStacksStackKuberneteOutput) } -// GetStackCloudformationInput is an input type that accepts GetStackCloudformationArgs and GetStackCloudformationOutput values. -// You can construct a concrete instance of `GetStackCloudformationInput` via: +type GetStacksStackPulumi struct { + LoginUrl string `pulumi:"loginUrl"` + StackName string `pulumi:"stackName"` +} + +// GetStacksStackPulumiInput is an input type that accepts GetStacksStackPulumiArgs and GetStacksStackPulumiOutput values. +// You can construct a concrete instance of `GetStacksStackPulumiInput` via: // -// GetStackCloudformationArgs{...} -type GetStackCloudformationInput interface { +// GetStacksStackPulumiArgs{...} +type GetStacksStackPulumiInput interface { pulumi.Input - ToGetStackCloudformationOutput() GetStackCloudformationOutput - ToGetStackCloudformationOutputWithContext(context.Context) GetStackCloudformationOutput + ToGetStacksStackPulumiOutput() GetStacksStackPulumiOutput + ToGetStacksStackPulumiOutputWithContext(context.Context) GetStacksStackPulumiOutput } -type GetStackCloudformationArgs struct { - EntryTemplateFile pulumi.StringInput `pulumi:"entryTemplateFile"` - Region pulumi.StringInput `pulumi:"region"` - StackName pulumi.StringInput `pulumi:"stackName"` - TemplateBucket pulumi.StringInput `pulumi:"templateBucket"` +type GetStacksStackPulumiArgs struct { + LoginUrl pulumi.StringInput `pulumi:"loginUrl"` + StackName pulumi.StringInput `pulumi:"stackName"` } -func (GetStackCloudformationArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackCloudformation)(nil)).Elem() +func (GetStacksStackPulumiArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackPulumi)(nil)).Elem() } -func (i GetStackCloudformationArgs) ToGetStackCloudformationOutput() GetStackCloudformationOutput { - return i.ToGetStackCloudformationOutputWithContext(context.Background()) +func (i GetStacksStackPulumiArgs) ToGetStacksStackPulumiOutput() GetStacksStackPulumiOutput { + return i.ToGetStacksStackPulumiOutputWithContext(context.Background()) } -func (i GetStackCloudformationArgs) ToGetStackCloudformationOutputWithContext(ctx context.Context) GetStackCloudformationOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackCloudformationOutput) +func (i GetStacksStackPulumiArgs) ToGetStacksStackPulumiOutputWithContext(ctx context.Context) GetStacksStackPulumiOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackPulumiOutput) } -// GetStackCloudformationArrayInput is an input type that accepts GetStackCloudformationArray and GetStackCloudformationArrayOutput values. -// You can construct a concrete instance of `GetStackCloudformationArrayInput` via: +func (i GetStacksStackPulumiArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackPulumi] { + return pulumix.Output[GetStacksStackPulumi]{ + OutputState: i.ToGetStacksStackPulumiOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackPulumiArrayInput is an input type that accepts GetStacksStackPulumiArray and GetStacksStackPulumiArrayOutput values. +// You can construct a concrete instance of `GetStacksStackPulumiArrayInput` via: // -// GetStackCloudformationArray{ GetStackCloudformationArgs{...} } -type GetStackCloudformationArrayInput interface { +// GetStacksStackPulumiArray{ GetStacksStackPulumiArgs{...} } +type GetStacksStackPulumiArrayInput interface { pulumi.Input - ToGetStackCloudformationArrayOutput() GetStackCloudformationArrayOutput - ToGetStackCloudformationArrayOutputWithContext(context.Context) GetStackCloudformationArrayOutput + ToGetStacksStackPulumiArrayOutput() GetStacksStackPulumiArrayOutput + ToGetStacksStackPulumiArrayOutputWithContext(context.Context) GetStacksStackPulumiArrayOutput } -type GetStackCloudformationArray []GetStackCloudformationInput +type GetStacksStackPulumiArray []GetStacksStackPulumiInput -func (GetStackCloudformationArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackCloudformation)(nil)).Elem() +func (GetStacksStackPulumiArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackPulumi)(nil)).Elem() } -func (i GetStackCloudformationArray) ToGetStackCloudformationArrayOutput() GetStackCloudformationArrayOutput { - return i.ToGetStackCloudformationArrayOutputWithContext(context.Background()) +func (i GetStacksStackPulumiArray) ToGetStacksStackPulumiArrayOutput() GetStacksStackPulumiArrayOutput { + return i.ToGetStacksStackPulumiArrayOutputWithContext(context.Background()) } -func (i GetStackCloudformationArray) ToGetStackCloudformationArrayOutputWithContext(ctx context.Context) GetStackCloudformationArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackCloudformationArrayOutput) +func (i GetStacksStackPulumiArray) ToGetStacksStackPulumiArrayOutputWithContext(ctx context.Context) GetStacksStackPulumiArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackPulumiArrayOutput) } -type GetStackCloudformationOutput struct{ *pulumi.OutputState } - -func (GetStackCloudformationOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackCloudformation)(nil)).Elem() +func (i GetStacksStackPulumiArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackPulumi] { + return pulumix.Output[[]GetStacksStackPulumi]{ + OutputState: i.ToGetStacksStackPulumiArrayOutputWithContext(ctx).OutputState, + } } -func (o GetStackCloudformationOutput) ToGetStackCloudformationOutput() GetStackCloudformationOutput { - return o +type GetStacksStackPulumiOutput struct{ *pulumi.OutputState } + +func (GetStacksStackPulumiOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackPulumi)(nil)).Elem() } -func (o GetStackCloudformationOutput) ToGetStackCloudformationOutputWithContext(ctx context.Context) GetStackCloudformationOutput { +func (o GetStacksStackPulumiOutput) ToGetStacksStackPulumiOutput() GetStacksStackPulumiOutput { return o } -func (o GetStackCloudformationOutput) EntryTemplateFile() pulumi.StringOutput { - return o.ApplyT(func(v GetStackCloudformation) string { return v.EntryTemplateFile }).(pulumi.StringOutput) +func (o GetStacksStackPulumiOutput) ToGetStacksStackPulumiOutputWithContext(ctx context.Context) GetStacksStackPulumiOutput { + return o } -func (o GetStackCloudformationOutput) Region() pulumi.StringOutput { - return o.ApplyT(func(v GetStackCloudformation) string { return v.Region }).(pulumi.StringOutput) +func (o GetStacksStackPulumiOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackPulumi] { + return pulumix.Output[GetStacksStackPulumi]{ + OutputState: o.OutputState, + } } -func (o GetStackCloudformationOutput) StackName() pulumi.StringOutput { - return o.ApplyT(func(v GetStackCloudformation) string { return v.StackName }).(pulumi.StringOutput) +func (o GetStacksStackPulumiOutput) LoginUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackPulumi) string { return v.LoginUrl }).(pulumi.StringOutput) } -func (o GetStackCloudformationOutput) TemplateBucket() pulumi.StringOutput { - return o.ApplyT(func(v GetStackCloudformation) string { return v.TemplateBucket }).(pulumi.StringOutput) +func (o GetStacksStackPulumiOutput) StackName() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackPulumi) string { return v.StackName }).(pulumi.StringOutput) } -type GetStackCloudformationArrayOutput struct{ *pulumi.OutputState } +type GetStacksStackPulumiArrayOutput struct{ *pulumi.OutputState } -func (GetStackCloudformationArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackCloudformation)(nil)).Elem() +func (GetStacksStackPulumiArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackPulumi)(nil)).Elem() } -func (o GetStackCloudformationArrayOutput) ToGetStackCloudformationArrayOutput() GetStackCloudformationArrayOutput { +func (o GetStacksStackPulumiArrayOutput) ToGetStacksStackPulumiArrayOutput() GetStacksStackPulumiArrayOutput { return o } -func (o GetStackCloudformationArrayOutput) ToGetStackCloudformationArrayOutputWithContext(ctx context.Context) GetStackCloudformationArrayOutput { +func (o GetStacksStackPulumiArrayOutput) ToGetStacksStackPulumiArrayOutputWithContext(ctx context.Context) GetStacksStackPulumiArrayOutput { return o } -func (o GetStackCloudformationArrayOutput) Index(i pulumi.IntInput) GetStackCloudformationOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackCloudformation { - return vs[0].([]GetStackCloudformation)[vs[1].(int)] - }).(GetStackCloudformationOutput) +func (o GetStacksStackPulumiArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackPulumi] { + return pulumix.Output[[]GetStacksStackPulumi]{ + OutputState: o.OutputState, + } } -type GetStackGithubEnterprise struct { +func (o GetStacksStackPulumiArrayOutput) Index(i pulumi.IntInput) GetStacksStackPulumiOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackPulumi { + return vs[0].([]GetStacksStackPulumi)[vs[1].(int)] + }).(GetStacksStackPulumiOutput) +} + +type GetStacksStackRawGit struct { Namespace string `pulumi:"namespace"` + Url string `pulumi:"url"` } -// GetStackGithubEnterpriseInput is an input type that accepts GetStackGithubEnterpriseArgs and GetStackGithubEnterpriseOutput values. -// You can construct a concrete instance of `GetStackGithubEnterpriseInput` via: +// GetStacksStackRawGitInput is an input type that accepts GetStacksStackRawGitArgs and GetStacksStackRawGitOutput values. +// You can construct a concrete instance of `GetStacksStackRawGitInput` via: // -// GetStackGithubEnterpriseArgs{...} -type GetStackGithubEnterpriseInput interface { +// GetStacksStackRawGitArgs{...} +type GetStacksStackRawGitInput interface { pulumi.Input - ToGetStackGithubEnterpriseOutput() GetStackGithubEnterpriseOutput - ToGetStackGithubEnterpriseOutputWithContext(context.Context) GetStackGithubEnterpriseOutput + ToGetStacksStackRawGitOutput() GetStacksStackRawGitOutput + ToGetStacksStackRawGitOutputWithContext(context.Context) GetStacksStackRawGitOutput } -type GetStackGithubEnterpriseArgs struct { +type GetStacksStackRawGitArgs struct { Namespace pulumi.StringInput `pulumi:"namespace"` + Url pulumi.StringInput `pulumi:"url"` } -func (GetStackGithubEnterpriseArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackGithubEnterprise)(nil)).Elem() +func (GetStacksStackRawGitArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackRawGit)(nil)).Elem() } -func (i GetStackGithubEnterpriseArgs) ToGetStackGithubEnterpriseOutput() GetStackGithubEnterpriseOutput { - return i.ToGetStackGithubEnterpriseOutputWithContext(context.Background()) +func (i GetStacksStackRawGitArgs) ToGetStacksStackRawGitOutput() GetStacksStackRawGitOutput { + return i.ToGetStacksStackRawGitOutputWithContext(context.Background()) } -func (i GetStackGithubEnterpriseArgs) ToGetStackGithubEnterpriseOutputWithContext(ctx context.Context) GetStackGithubEnterpriseOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackGithubEnterpriseOutput) +func (i GetStacksStackRawGitArgs) ToGetStacksStackRawGitOutputWithContext(ctx context.Context) GetStacksStackRawGitOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackRawGitOutput) } -// GetStackGithubEnterpriseArrayInput is an input type that accepts GetStackGithubEnterpriseArray and GetStackGithubEnterpriseArrayOutput values. -// You can construct a concrete instance of `GetStackGithubEnterpriseArrayInput` via: +func (i GetStacksStackRawGitArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackRawGit] { + return pulumix.Output[GetStacksStackRawGit]{ + OutputState: i.ToGetStacksStackRawGitOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackRawGitArrayInput is an input type that accepts GetStacksStackRawGitArray and GetStacksStackRawGitArrayOutput values. +// You can construct a concrete instance of `GetStacksStackRawGitArrayInput` via: // -// GetStackGithubEnterpriseArray{ GetStackGithubEnterpriseArgs{...} } -type GetStackGithubEnterpriseArrayInput interface { +// GetStacksStackRawGitArray{ GetStacksStackRawGitArgs{...} } +type GetStacksStackRawGitArrayInput interface { pulumi.Input - ToGetStackGithubEnterpriseArrayOutput() GetStackGithubEnterpriseArrayOutput - ToGetStackGithubEnterpriseArrayOutputWithContext(context.Context) GetStackGithubEnterpriseArrayOutput + ToGetStacksStackRawGitArrayOutput() GetStacksStackRawGitArrayOutput + ToGetStacksStackRawGitArrayOutputWithContext(context.Context) GetStacksStackRawGitArrayOutput } -type GetStackGithubEnterpriseArray []GetStackGithubEnterpriseInput +type GetStacksStackRawGitArray []GetStacksStackRawGitInput -func (GetStackGithubEnterpriseArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackGithubEnterprise)(nil)).Elem() +func (GetStacksStackRawGitArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackRawGit)(nil)).Elem() } -func (i GetStackGithubEnterpriseArray) ToGetStackGithubEnterpriseArrayOutput() GetStackGithubEnterpriseArrayOutput { - return i.ToGetStackGithubEnterpriseArrayOutputWithContext(context.Background()) +func (i GetStacksStackRawGitArray) ToGetStacksStackRawGitArrayOutput() GetStacksStackRawGitArrayOutput { + return i.ToGetStacksStackRawGitArrayOutputWithContext(context.Background()) } -func (i GetStackGithubEnterpriseArray) ToGetStackGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetStackGithubEnterpriseArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackGithubEnterpriseArrayOutput) +func (i GetStacksStackRawGitArray) ToGetStacksStackRawGitArrayOutputWithContext(ctx context.Context) GetStacksStackRawGitArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackRawGitArrayOutput) } -type GetStackGithubEnterpriseOutput struct{ *pulumi.OutputState } +func (i GetStacksStackRawGitArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackRawGit] { + return pulumix.Output[[]GetStacksStackRawGit]{ + OutputState: i.ToGetStacksStackRawGitArrayOutputWithContext(ctx).OutputState, + } +} -func (GetStackGithubEnterpriseOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackGithubEnterprise)(nil)).Elem() +type GetStacksStackRawGitOutput struct{ *pulumi.OutputState } + +func (GetStacksStackRawGitOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackRawGit)(nil)).Elem() } -func (o GetStackGithubEnterpriseOutput) ToGetStackGithubEnterpriseOutput() GetStackGithubEnterpriseOutput { +func (o GetStacksStackRawGitOutput) ToGetStacksStackRawGitOutput() GetStacksStackRawGitOutput { return o } -func (o GetStackGithubEnterpriseOutput) ToGetStackGithubEnterpriseOutputWithContext(ctx context.Context) GetStackGithubEnterpriseOutput { +func (o GetStacksStackRawGitOutput) ToGetStacksStackRawGitOutputWithContext(ctx context.Context) GetStacksStackRawGitOutput { return o } -func (o GetStackGithubEnterpriseOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetStackGithubEnterprise) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStackRawGitOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackRawGit] { + return pulumix.Output[GetStacksStackRawGit]{ + OutputState: o.OutputState, + } } -type GetStackGithubEnterpriseArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackRawGitOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackRawGit) string { return v.Namespace }).(pulumi.StringOutput) +} -func (GetStackGithubEnterpriseArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackGithubEnterprise)(nil)).Elem() +func (o GetStacksStackRawGitOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackRawGit) string { return v.Url }).(pulumi.StringOutput) } -func (o GetStackGithubEnterpriseArrayOutput) ToGetStackGithubEnterpriseArrayOutput() GetStackGithubEnterpriseArrayOutput { +type GetStacksStackRawGitArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackRawGitArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackRawGit)(nil)).Elem() +} + +func (o GetStacksStackRawGitArrayOutput) ToGetStacksStackRawGitArrayOutput() GetStacksStackRawGitArrayOutput { return o } -func (o GetStackGithubEnterpriseArrayOutput) ToGetStackGithubEnterpriseArrayOutputWithContext(ctx context.Context) GetStackGithubEnterpriseArrayOutput { +func (o GetStacksStackRawGitArrayOutput) ToGetStacksStackRawGitArrayOutputWithContext(ctx context.Context) GetStacksStackRawGitArrayOutput { return o } -func (o GetStackGithubEnterpriseArrayOutput) Index(i pulumi.IntInput) GetStackGithubEnterpriseOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackGithubEnterprise { - return vs[0].([]GetStackGithubEnterprise)[vs[1].(int)] - }).(GetStackGithubEnterpriseOutput) +func (o GetStacksStackRawGitArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackRawGit] { + return pulumix.Output[[]GetStacksStackRawGit]{ + OutputState: o.OutputState, + } } -type GetStackGitlab struct { +func (o GetStacksStackRawGitArrayOutput) Index(i pulumi.IntInput) GetStacksStackRawGitOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackRawGit { + return vs[0].([]GetStacksStackRawGit)[vs[1].(int)] + }).(GetStacksStackRawGitOutput) +} + +type GetStacksStackShowcase struct { Namespace string `pulumi:"namespace"` } -// GetStackGitlabInput is an input type that accepts GetStackGitlabArgs and GetStackGitlabOutput values. -// You can construct a concrete instance of `GetStackGitlabInput` via: +// GetStacksStackShowcaseInput is an input type that accepts GetStacksStackShowcaseArgs and GetStacksStackShowcaseOutput values. +// You can construct a concrete instance of `GetStacksStackShowcaseInput` via: // -// GetStackGitlabArgs{...} -type GetStackGitlabInput interface { +// GetStacksStackShowcaseArgs{...} +type GetStacksStackShowcaseInput interface { pulumi.Input - ToGetStackGitlabOutput() GetStackGitlabOutput - ToGetStackGitlabOutputWithContext(context.Context) GetStackGitlabOutput + ToGetStacksStackShowcaseOutput() GetStacksStackShowcaseOutput + ToGetStacksStackShowcaseOutputWithContext(context.Context) GetStacksStackShowcaseOutput } -type GetStackGitlabArgs struct { +type GetStacksStackShowcaseArgs struct { Namespace pulumi.StringInput `pulumi:"namespace"` } -func (GetStackGitlabArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackGitlab)(nil)).Elem() +func (GetStacksStackShowcaseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackShowcase)(nil)).Elem() } -func (i GetStackGitlabArgs) ToGetStackGitlabOutput() GetStackGitlabOutput { - return i.ToGetStackGitlabOutputWithContext(context.Background()) +func (i GetStacksStackShowcaseArgs) ToGetStacksStackShowcaseOutput() GetStacksStackShowcaseOutput { + return i.ToGetStacksStackShowcaseOutputWithContext(context.Background()) } -func (i GetStackGitlabArgs) ToGetStackGitlabOutputWithContext(ctx context.Context) GetStackGitlabOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackGitlabOutput) +func (i GetStacksStackShowcaseArgs) ToGetStacksStackShowcaseOutputWithContext(ctx context.Context) GetStacksStackShowcaseOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackShowcaseOutput) } -// GetStackGitlabArrayInput is an input type that accepts GetStackGitlabArray and GetStackGitlabArrayOutput values. -// You can construct a concrete instance of `GetStackGitlabArrayInput` via: +func (i GetStacksStackShowcaseArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackShowcase] { + return pulumix.Output[GetStacksStackShowcase]{ + OutputState: i.ToGetStacksStackShowcaseOutputWithContext(ctx).OutputState, + } +} + +// GetStacksStackShowcaseArrayInput is an input type that accepts GetStacksStackShowcaseArray and GetStacksStackShowcaseArrayOutput values. +// You can construct a concrete instance of `GetStacksStackShowcaseArrayInput` via: // -// GetStackGitlabArray{ GetStackGitlabArgs{...} } -type GetStackGitlabArrayInput interface { +// GetStacksStackShowcaseArray{ GetStacksStackShowcaseArgs{...} } +type GetStacksStackShowcaseArrayInput interface { pulumi.Input - ToGetStackGitlabArrayOutput() GetStackGitlabArrayOutput - ToGetStackGitlabArrayOutputWithContext(context.Context) GetStackGitlabArrayOutput + ToGetStacksStackShowcaseArrayOutput() GetStacksStackShowcaseArrayOutput + ToGetStacksStackShowcaseArrayOutputWithContext(context.Context) GetStacksStackShowcaseArrayOutput } -type GetStackGitlabArray []GetStackGitlabInput +type GetStacksStackShowcaseArray []GetStacksStackShowcaseInput -func (GetStackGitlabArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackGitlab)(nil)).Elem() +func (GetStacksStackShowcaseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackShowcase)(nil)).Elem() } -func (i GetStackGitlabArray) ToGetStackGitlabArrayOutput() GetStackGitlabArrayOutput { - return i.ToGetStackGitlabArrayOutputWithContext(context.Background()) +func (i GetStacksStackShowcaseArray) ToGetStacksStackShowcaseArrayOutput() GetStacksStackShowcaseArrayOutput { + return i.ToGetStacksStackShowcaseArrayOutputWithContext(context.Background()) } -func (i GetStackGitlabArray) ToGetStackGitlabArrayOutputWithContext(ctx context.Context) GetStackGitlabArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackGitlabArrayOutput) +func (i GetStacksStackShowcaseArray) ToGetStacksStackShowcaseArrayOutputWithContext(ctx context.Context) GetStacksStackShowcaseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStackShowcaseArrayOutput) } -type GetStackGitlabOutput struct{ *pulumi.OutputState } +func (i GetStacksStackShowcaseArray) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackShowcase] { + return pulumix.Output[[]GetStacksStackShowcase]{ + OutputState: i.ToGetStacksStackShowcaseArrayOutputWithContext(ctx).OutputState, + } +} -func (GetStackGitlabOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackGitlab)(nil)).Elem() +type GetStacksStackShowcaseOutput struct{ *pulumi.OutputState } + +func (GetStacksStackShowcaseOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksStackShowcase)(nil)).Elem() } -func (o GetStackGitlabOutput) ToGetStackGitlabOutput() GetStackGitlabOutput { +func (o GetStacksStackShowcaseOutput) ToGetStacksStackShowcaseOutput() GetStacksStackShowcaseOutput { return o } -func (o GetStackGitlabOutput) ToGetStackGitlabOutputWithContext(ctx context.Context) GetStackGitlabOutput { +func (o GetStacksStackShowcaseOutput) ToGetStacksStackShowcaseOutputWithContext(ctx context.Context) GetStacksStackShowcaseOutput { return o } -func (o GetStackGitlabOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetStackGitlab) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStackShowcaseOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksStackShowcase] { + return pulumix.Output[GetStacksStackShowcase]{ + OutputState: o.OutputState, + } } -type GetStackGitlabArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStackShowcaseOutput) Namespace() pulumi.StringOutput { + return o.ApplyT(func(v GetStacksStackShowcase) string { return v.Namespace }).(pulumi.StringOutput) +} -func (GetStackGitlabArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackGitlab)(nil)).Elem() +type GetStacksStackShowcaseArrayOutput struct{ *pulumi.OutputState } + +func (GetStacksStackShowcaseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetStacksStackShowcase)(nil)).Elem() +} + +func (o GetStacksStackShowcaseArrayOutput) ToGetStacksStackShowcaseArrayOutput() GetStacksStackShowcaseArrayOutput { + return o } -func (o GetStackGitlabArrayOutput) ToGetStackGitlabArrayOutput() GetStackGitlabArrayOutput { +func (o GetStacksStackShowcaseArrayOutput) ToGetStacksStackShowcaseArrayOutputWithContext(ctx context.Context) GetStacksStackShowcaseArrayOutput { return o } -func (o GetStackGitlabArrayOutput) ToGetStackGitlabArrayOutputWithContext(ctx context.Context) GetStackGitlabArrayOutput { - return o +func (o GetStacksStackShowcaseArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetStacksStackShowcase] { + return pulumix.Output[[]GetStacksStackShowcase]{ + OutputState: o.OutputState, + } } -func (o GetStackGitlabArrayOutput) Index(i pulumi.IntInput) GetStackGitlabOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackGitlab { - return vs[0].([]GetStackGitlab)[vs[1].(int)] - }).(GetStackGitlabOutput) +func (o GetStacksStackShowcaseArrayOutput) Index(i pulumi.IntInput) GetStacksStackShowcaseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStacksStackShowcase { + return vs[0].([]GetStacksStackShowcase)[vs[1].(int)] + }).(GetStacksStackShowcaseOutput) } -type GetStackKubernete struct { - Namespace string `pulumi:"namespace"` +type GetStacksState struct { + AnyOfs []string `pulumi:"anyOfs"` } -// GetStackKuberneteInput is an input type that accepts GetStackKuberneteArgs and GetStackKuberneteOutput values. -// You can construct a concrete instance of `GetStackKuberneteInput` via: +// GetStacksStateInput is an input type that accepts GetStacksStateArgs and GetStacksStateOutput values. +// You can construct a concrete instance of `GetStacksStateInput` via: // -// GetStackKuberneteArgs{...} -type GetStackKuberneteInput interface { +// GetStacksStateArgs{...} +type GetStacksStateInput interface { pulumi.Input - ToGetStackKuberneteOutput() GetStackKuberneteOutput - ToGetStackKuberneteOutputWithContext(context.Context) GetStackKuberneteOutput + ToGetStacksStateOutput() GetStacksStateOutput + ToGetStacksStateOutputWithContext(context.Context) GetStacksStateOutput } -type GetStackKuberneteArgs struct { - Namespace pulumi.StringInput `pulumi:"namespace"` +type GetStacksStateArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` } -func (GetStackKuberneteArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackKubernete)(nil)).Elem() +func (GetStacksStateArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksState)(nil)).Elem() } -func (i GetStackKuberneteArgs) ToGetStackKuberneteOutput() GetStackKuberneteOutput { - return i.ToGetStackKuberneteOutputWithContext(context.Background()) +func (i GetStacksStateArgs) ToGetStacksStateOutput() GetStacksStateOutput { + return i.ToGetStacksStateOutputWithContext(context.Background()) } -func (i GetStackKuberneteArgs) ToGetStackKuberneteOutputWithContext(ctx context.Context) GetStackKuberneteOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackKuberneteOutput) +func (i GetStacksStateArgs) ToGetStacksStateOutputWithContext(ctx context.Context) GetStacksStateOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStateOutput) } -// GetStackKuberneteArrayInput is an input type that accepts GetStackKuberneteArray and GetStackKuberneteArrayOutput values. -// You can construct a concrete instance of `GetStackKuberneteArrayInput` via: +func (i GetStacksStateArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksState] { + return pulumix.Output[GetStacksState]{ + OutputState: i.ToGetStacksStateOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksStateArgs) ToGetStacksStatePtrOutput() GetStacksStatePtrOutput { + return i.ToGetStacksStatePtrOutputWithContext(context.Background()) +} + +func (i GetStacksStateArgs) ToGetStacksStatePtrOutputWithContext(ctx context.Context) GetStacksStatePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStateOutput).ToGetStacksStatePtrOutputWithContext(ctx) +} + +// GetStacksStatePtrInput is an input type that accepts GetStacksStateArgs, GetStacksStatePtr and GetStacksStatePtrOutput values. +// You can construct a concrete instance of `GetStacksStatePtrInput` via: // -// GetStackKuberneteArray{ GetStackKuberneteArgs{...} } -type GetStackKuberneteArrayInput interface { +// GetStacksStateArgs{...} +// +// or: +// +// nil +type GetStacksStatePtrInput interface { pulumi.Input - ToGetStackKuberneteArrayOutput() GetStackKuberneteArrayOutput - ToGetStackKuberneteArrayOutputWithContext(context.Context) GetStackKuberneteArrayOutput + ToGetStacksStatePtrOutput() GetStacksStatePtrOutput + ToGetStacksStatePtrOutputWithContext(context.Context) GetStacksStatePtrOutput } -type GetStackKuberneteArray []GetStackKuberneteInput +type getStacksStatePtrType GetStacksStateArgs -func (GetStackKuberneteArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackKubernete)(nil)).Elem() +func GetStacksStatePtr(v *GetStacksStateArgs) GetStacksStatePtrInput { + return (*getStacksStatePtrType)(v) } -func (i GetStackKuberneteArray) ToGetStackKuberneteArrayOutput() GetStackKuberneteArrayOutput { - return i.ToGetStackKuberneteArrayOutputWithContext(context.Background()) +func (*getStacksStatePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksState)(nil)).Elem() } -func (i GetStackKuberneteArray) ToGetStackKuberneteArrayOutputWithContext(ctx context.Context) GetStackKuberneteArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackKuberneteArrayOutput) +func (i *getStacksStatePtrType) ToGetStacksStatePtrOutput() GetStacksStatePtrOutput { + return i.ToGetStacksStatePtrOutputWithContext(context.Background()) } -type GetStackKuberneteOutput struct{ *pulumi.OutputState } +func (i *getStacksStatePtrType) ToGetStacksStatePtrOutputWithContext(ctx context.Context) GetStacksStatePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksStatePtrOutput) +} -func (GetStackKuberneteOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackKubernete)(nil)).Elem() +func (i *getStacksStatePtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksState] { + return pulumix.Output[*GetStacksState]{ + OutputState: i.ToGetStacksStatePtrOutputWithContext(ctx).OutputState, + } } -func (o GetStackKuberneteOutput) ToGetStackKuberneteOutput() GetStackKuberneteOutput { +type GetStacksStateOutput struct{ *pulumi.OutputState } + +func (GetStacksStateOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksState)(nil)).Elem() +} + +func (o GetStacksStateOutput) ToGetStacksStateOutput() GetStacksStateOutput { return o } -func (o GetStackKuberneteOutput) ToGetStackKuberneteOutputWithContext(ctx context.Context) GetStackKuberneteOutput { +func (o GetStacksStateOutput) ToGetStacksStateOutputWithContext(ctx context.Context) GetStacksStateOutput { return o } -func (o GetStackKuberneteOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetStackKubernete) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksStateOutput) ToGetStacksStatePtrOutput() GetStacksStatePtrOutput { + return o.ToGetStacksStatePtrOutputWithContext(context.Background()) } -type GetStackKuberneteArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksStateOutput) ToGetStacksStatePtrOutputWithContext(ctx context.Context) GetStacksStatePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksState) *GetStacksState { + return &v + }).(GetStacksStatePtrOutput) +} -func (GetStackKuberneteArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackKubernete)(nil)).Elem() +func (o GetStacksStateOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksState] { + return pulumix.Output[GetStacksState]{ + OutputState: o.OutputState, + } } -func (o GetStackKuberneteArrayOutput) ToGetStackKuberneteArrayOutput() GetStackKuberneteArrayOutput { +func (o GetStacksStateOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksState) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetStacksStatePtrOutput struct{ *pulumi.OutputState } + +func (GetStacksStatePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksState)(nil)).Elem() +} + +func (o GetStacksStatePtrOutput) ToGetStacksStatePtrOutput() GetStacksStatePtrOutput { return o } -func (o GetStackKuberneteArrayOutput) ToGetStackKuberneteArrayOutputWithContext(ctx context.Context) GetStackKuberneteArrayOutput { +func (o GetStacksStatePtrOutput) ToGetStacksStatePtrOutputWithContext(ctx context.Context) GetStacksStatePtrOutput { return o } -func (o GetStackKuberneteArrayOutput) Index(i pulumi.IntInput) GetStackKuberneteOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackKubernete { - return vs[0].([]GetStackKubernete)[vs[1].(int)] - }).(GetStackKuberneteOutput) +func (o GetStacksStatePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksState] { + return pulumix.Output[*GetStacksState]{ + OutputState: o.OutputState, + } } -type GetStackPulumi struct { - LoginUrl string `pulumi:"loginUrl"` - StackName string `pulumi:"stackName"` +func (o GetStacksStatePtrOutput) Elem() GetStacksStateOutput { + return o.ApplyT(func(v *GetStacksState) GetStacksState { + if v != nil { + return *v + } + var ret GetStacksState + return ret + }).(GetStacksStateOutput) } -// GetStackPulumiInput is an input type that accepts GetStackPulumiArgs and GetStackPulumiOutput values. -// You can construct a concrete instance of `GetStackPulumiInput` via: +func (o GetStacksStatePtrOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GetStacksState) []string { + if v == nil { + return nil + } + return v.AnyOfs + }).(pulumi.StringArrayOutput) +} + +type GetStacksVendor struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetStacksVendorInput is an input type that accepts GetStacksVendorArgs and GetStacksVendorOutput values. +// You can construct a concrete instance of `GetStacksVendorInput` via: // -// GetStackPulumiArgs{...} -type GetStackPulumiInput interface { +// GetStacksVendorArgs{...} +type GetStacksVendorInput interface { pulumi.Input - ToGetStackPulumiOutput() GetStackPulumiOutput - ToGetStackPulumiOutputWithContext(context.Context) GetStackPulumiOutput + ToGetStacksVendorOutput() GetStacksVendorOutput + ToGetStacksVendorOutputWithContext(context.Context) GetStacksVendorOutput } -type GetStackPulumiArgs struct { - LoginUrl pulumi.StringInput `pulumi:"loginUrl"` - StackName pulumi.StringInput `pulumi:"stackName"` +type GetStacksVendorArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` } -func (GetStackPulumiArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackPulumi)(nil)).Elem() +func (GetStacksVendorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksVendor)(nil)).Elem() } -func (i GetStackPulumiArgs) ToGetStackPulumiOutput() GetStackPulumiOutput { - return i.ToGetStackPulumiOutputWithContext(context.Background()) +func (i GetStacksVendorArgs) ToGetStacksVendorOutput() GetStacksVendorOutput { + return i.ToGetStacksVendorOutputWithContext(context.Background()) } -func (i GetStackPulumiArgs) ToGetStackPulumiOutputWithContext(ctx context.Context) GetStackPulumiOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackPulumiOutput) +func (i GetStacksVendorArgs) ToGetStacksVendorOutputWithContext(ctx context.Context) GetStacksVendorOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksVendorOutput) } -// GetStackPulumiArrayInput is an input type that accepts GetStackPulumiArray and GetStackPulumiArrayOutput values. -// You can construct a concrete instance of `GetStackPulumiArrayInput` via: +func (i GetStacksVendorArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksVendor] { + return pulumix.Output[GetStacksVendor]{ + OutputState: i.ToGetStacksVendorOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksVendorArgs) ToGetStacksVendorPtrOutput() GetStacksVendorPtrOutput { + return i.ToGetStacksVendorPtrOutputWithContext(context.Background()) +} + +func (i GetStacksVendorArgs) ToGetStacksVendorPtrOutputWithContext(ctx context.Context) GetStacksVendorPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksVendorOutput).ToGetStacksVendorPtrOutputWithContext(ctx) +} + +// GetStacksVendorPtrInput is an input type that accepts GetStacksVendorArgs, GetStacksVendorPtr and GetStacksVendorPtrOutput values. +// You can construct a concrete instance of `GetStacksVendorPtrInput` via: // -// GetStackPulumiArray{ GetStackPulumiArgs{...} } -type GetStackPulumiArrayInput interface { +// GetStacksVendorArgs{...} +// +// or: +// +// nil +type GetStacksVendorPtrInput interface { pulumi.Input - ToGetStackPulumiArrayOutput() GetStackPulumiArrayOutput - ToGetStackPulumiArrayOutputWithContext(context.Context) GetStackPulumiArrayOutput + ToGetStacksVendorPtrOutput() GetStacksVendorPtrOutput + ToGetStacksVendorPtrOutputWithContext(context.Context) GetStacksVendorPtrOutput } -type GetStackPulumiArray []GetStackPulumiInput +type getStacksVendorPtrType GetStacksVendorArgs -func (GetStackPulumiArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackPulumi)(nil)).Elem() +func GetStacksVendorPtr(v *GetStacksVendorArgs) GetStacksVendorPtrInput { + return (*getStacksVendorPtrType)(v) } -func (i GetStackPulumiArray) ToGetStackPulumiArrayOutput() GetStackPulumiArrayOutput { - return i.ToGetStackPulumiArrayOutputWithContext(context.Background()) +func (*getStacksVendorPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksVendor)(nil)).Elem() } -func (i GetStackPulumiArray) ToGetStackPulumiArrayOutputWithContext(ctx context.Context) GetStackPulumiArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackPulumiArrayOutput) +func (i *getStacksVendorPtrType) ToGetStacksVendorPtrOutput() GetStacksVendorPtrOutput { + return i.ToGetStacksVendorPtrOutputWithContext(context.Background()) } -type GetStackPulumiOutput struct{ *pulumi.OutputState } +func (i *getStacksVendorPtrType) ToGetStacksVendorPtrOutputWithContext(ctx context.Context) GetStacksVendorPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksVendorPtrOutput) +} -func (GetStackPulumiOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackPulumi)(nil)).Elem() +func (i *getStacksVendorPtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksVendor] { + return pulumix.Output[*GetStacksVendor]{ + OutputState: i.ToGetStacksVendorPtrOutputWithContext(ctx).OutputState, + } } -func (o GetStackPulumiOutput) ToGetStackPulumiOutput() GetStackPulumiOutput { +type GetStacksVendorOutput struct{ *pulumi.OutputState } + +func (GetStacksVendorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksVendor)(nil)).Elem() +} + +func (o GetStacksVendorOutput) ToGetStacksVendorOutput() GetStacksVendorOutput { return o } -func (o GetStackPulumiOutput) ToGetStackPulumiOutputWithContext(ctx context.Context) GetStackPulumiOutput { +func (o GetStacksVendorOutput) ToGetStacksVendorOutputWithContext(ctx context.Context) GetStacksVendorOutput { return o } -func (o GetStackPulumiOutput) LoginUrl() pulumi.StringOutput { - return o.ApplyT(func(v GetStackPulumi) string { return v.LoginUrl }).(pulumi.StringOutput) +func (o GetStacksVendorOutput) ToGetStacksVendorPtrOutput() GetStacksVendorPtrOutput { + return o.ToGetStacksVendorPtrOutputWithContext(context.Background()) } -func (o GetStackPulumiOutput) StackName() pulumi.StringOutput { - return o.ApplyT(func(v GetStackPulumi) string { return v.StackName }).(pulumi.StringOutput) +func (o GetStacksVendorOutput) ToGetStacksVendorPtrOutputWithContext(ctx context.Context) GetStacksVendorPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksVendor) *GetStacksVendor { + return &v + }).(GetStacksVendorPtrOutput) } -type GetStackPulumiArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksVendorOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksVendor] { + return pulumix.Output[GetStacksVendor]{ + OutputState: o.OutputState, + } +} -func (GetStackPulumiArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackPulumi)(nil)).Elem() +func (o GetStacksVendorOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksVendor) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) } -func (o GetStackPulumiArrayOutput) ToGetStackPulumiArrayOutput() GetStackPulumiArrayOutput { +type GetStacksVendorPtrOutput struct{ *pulumi.OutputState } + +func (GetStacksVendorPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksVendor)(nil)).Elem() +} + +func (o GetStacksVendorPtrOutput) ToGetStacksVendorPtrOutput() GetStacksVendorPtrOutput { return o } -func (o GetStackPulumiArrayOutput) ToGetStackPulumiArrayOutputWithContext(ctx context.Context) GetStackPulumiArrayOutput { +func (o GetStacksVendorPtrOutput) ToGetStacksVendorPtrOutputWithContext(ctx context.Context) GetStacksVendorPtrOutput { return o } -func (o GetStackPulumiArrayOutput) Index(i pulumi.IntInput) GetStackPulumiOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackPulumi { - return vs[0].([]GetStackPulumi)[vs[1].(int)] - }).(GetStackPulumiOutput) +func (o GetStacksVendorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksVendor] { + return pulumix.Output[*GetStacksVendor]{ + OutputState: o.OutputState, + } } -type GetStackShowcase struct { - Namespace string `pulumi:"namespace"` +func (o GetStacksVendorPtrOutput) Elem() GetStacksVendorOutput { + return o.ApplyT(func(v *GetStacksVendor) GetStacksVendor { + if v != nil { + return *v + } + var ret GetStacksVendor + return ret + }).(GetStacksVendorOutput) } -// GetStackShowcaseInput is an input type that accepts GetStackShowcaseArgs and GetStackShowcaseOutput values. -// You can construct a concrete instance of `GetStackShowcaseInput` via: +func (o GetStacksVendorPtrOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GetStacksVendor) []string { + if v == nil { + return nil + } + return v.AnyOfs + }).(pulumi.StringArrayOutput) +} + +type GetStacksWorkerPool struct { + AnyOfs []string `pulumi:"anyOfs"` +} + +// GetStacksWorkerPoolInput is an input type that accepts GetStacksWorkerPoolArgs and GetStacksWorkerPoolOutput values. +// You can construct a concrete instance of `GetStacksWorkerPoolInput` via: // -// GetStackShowcaseArgs{...} -type GetStackShowcaseInput interface { +// GetStacksWorkerPoolArgs{...} +type GetStacksWorkerPoolInput interface { pulumi.Input - ToGetStackShowcaseOutput() GetStackShowcaseOutput - ToGetStackShowcaseOutputWithContext(context.Context) GetStackShowcaseOutput + ToGetStacksWorkerPoolOutput() GetStacksWorkerPoolOutput + ToGetStacksWorkerPoolOutputWithContext(context.Context) GetStacksWorkerPoolOutput } -type GetStackShowcaseArgs struct { - Namespace pulumi.StringInput `pulumi:"namespace"` +type GetStacksWorkerPoolArgs struct { + AnyOfs pulumi.StringArrayInput `pulumi:"anyOfs"` } -func (GetStackShowcaseArgs) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackShowcase)(nil)).Elem() +func (GetStacksWorkerPoolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksWorkerPool)(nil)).Elem() } -func (i GetStackShowcaseArgs) ToGetStackShowcaseOutput() GetStackShowcaseOutput { - return i.ToGetStackShowcaseOutputWithContext(context.Background()) +func (i GetStacksWorkerPoolArgs) ToGetStacksWorkerPoolOutput() GetStacksWorkerPoolOutput { + return i.ToGetStacksWorkerPoolOutputWithContext(context.Background()) } -func (i GetStackShowcaseArgs) ToGetStackShowcaseOutputWithContext(ctx context.Context) GetStackShowcaseOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackShowcaseOutput) +func (i GetStacksWorkerPoolArgs) ToGetStacksWorkerPoolOutputWithContext(ctx context.Context) GetStacksWorkerPoolOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksWorkerPoolOutput) } -// GetStackShowcaseArrayInput is an input type that accepts GetStackShowcaseArray and GetStackShowcaseArrayOutput values. -// You can construct a concrete instance of `GetStackShowcaseArrayInput` via: +func (i GetStacksWorkerPoolArgs) ToOutput(ctx context.Context) pulumix.Output[GetStacksWorkerPool] { + return pulumix.Output[GetStacksWorkerPool]{ + OutputState: i.ToGetStacksWorkerPoolOutputWithContext(ctx).OutputState, + } +} + +func (i GetStacksWorkerPoolArgs) ToGetStacksWorkerPoolPtrOutput() GetStacksWorkerPoolPtrOutput { + return i.ToGetStacksWorkerPoolPtrOutputWithContext(context.Background()) +} + +func (i GetStacksWorkerPoolArgs) ToGetStacksWorkerPoolPtrOutputWithContext(ctx context.Context) GetStacksWorkerPoolPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksWorkerPoolOutput).ToGetStacksWorkerPoolPtrOutputWithContext(ctx) +} + +// GetStacksWorkerPoolPtrInput is an input type that accepts GetStacksWorkerPoolArgs, GetStacksWorkerPoolPtr and GetStacksWorkerPoolPtrOutput values. +// You can construct a concrete instance of `GetStacksWorkerPoolPtrInput` via: // -// GetStackShowcaseArray{ GetStackShowcaseArgs{...} } -type GetStackShowcaseArrayInput interface { +// GetStacksWorkerPoolArgs{...} +// +// or: +// +// nil +type GetStacksWorkerPoolPtrInput interface { pulumi.Input - ToGetStackShowcaseArrayOutput() GetStackShowcaseArrayOutput - ToGetStackShowcaseArrayOutputWithContext(context.Context) GetStackShowcaseArrayOutput + ToGetStacksWorkerPoolPtrOutput() GetStacksWorkerPoolPtrOutput + ToGetStacksWorkerPoolPtrOutputWithContext(context.Context) GetStacksWorkerPoolPtrOutput } -type GetStackShowcaseArray []GetStackShowcaseInput +type getStacksWorkerPoolPtrType GetStacksWorkerPoolArgs -func (GetStackShowcaseArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackShowcase)(nil)).Elem() +func GetStacksWorkerPoolPtr(v *GetStacksWorkerPoolArgs) GetStacksWorkerPoolPtrInput { + return (*getStacksWorkerPoolPtrType)(v) } -func (i GetStackShowcaseArray) ToGetStackShowcaseArrayOutput() GetStackShowcaseArrayOutput { - return i.ToGetStackShowcaseArrayOutputWithContext(context.Background()) +func (*getStacksWorkerPoolPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksWorkerPool)(nil)).Elem() } -func (i GetStackShowcaseArray) ToGetStackShowcaseArrayOutputWithContext(ctx context.Context) GetStackShowcaseArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(GetStackShowcaseArrayOutput) +func (i *getStacksWorkerPoolPtrType) ToGetStacksWorkerPoolPtrOutput() GetStacksWorkerPoolPtrOutput { + return i.ToGetStacksWorkerPoolPtrOutputWithContext(context.Background()) } -type GetStackShowcaseOutput struct{ *pulumi.OutputState } +func (i *getStacksWorkerPoolPtrType) ToGetStacksWorkerPoolPtrOutputWithContext(ctx context.Context) GetStacksWorkerPoolPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetStacksWorkerPoolPtrOutput) +} -func (GetStackShowcaseOutput) ElementType() reflect.Type { - return reflect.TypeOf((*GetStackShowcase)(nil)).Elem() +func (i *getStacksWorkerPoolPtrType) ToOutput(ctx context.Context) pulumix.Output[*GetStacksWorkerPool] { + return pulumix.Output[*GetStacksWorkerPool]{ + OutputState: i.ToGetStacksWorkerPoolPtrOutputWithContext(ctx).OutputState, + } } -func (o GetStackShowcaseOutput) ToGetStackShowcaseOutput() GetStackShowcaseOutput { +type GetStacksWorkerPoolOutput struct{ *pulumi.OutputState } + +func (GetStacksWorkerPoolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetStacksWorkerPool)(nil)).Elem() +} + +func (o GetStacksWorkerPoolOutput) ToGetStacksWorkerPoolOutput() GetStacksWorkerPoolOutput { return o } -func (o GetStackShowcaseOutput) ToGetStackShowcaseOutputWithContext(ctx context.Context) GetStackShowcaseOutput { +func (o GetStacksWorkerPoolOutput) ToGetStacksWorkerPoolOutputWithContext(ctx context.Context) GetStacksWorkerPoolOutput { return o } -func (o GetStackShowcaseOutput) Namespace() pulumi.StringOutput { - return o.ApplyT(func(v GetStackShowcase) string { return v.Namespace }).(pulumi.StringOutput) +func (o GetStacksWorkerPoolOutput) ToGetStacksWorkerPoolPtrOutput() GetStacksWorkerPoolPtrOutput { + return o.ToGetStacksWorkerPoolPtrOutputWithContext(context.Background()) } -type GetStackShowcaseArrayOutput struct{ *pulumi.OutputState } +func (o GetStacksWorkerPoolOutput) ToGetStacksWorkerPoolPtrOutputWithContext(ctx context.Context) GetStacksWorkerPoolPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetStacksWorkerPool) *GetStacksWorkerPool { + return &v + }).(GetStacksWorkerPoolPtrOutput) +} -func (GetStackShowcaseArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]GetStackShowcase)(nil)).Elem() +func (o GetStacksWorkerPoolOutput) ToOutput(ctx context.Context) pulumix.Output[GetStacksWorkerPool] { + return pulumix.Output[GetStacksWorkerPool]{ + OutputState: o.OutputState, + } } -func (o GetStackShowcaseArrayOutput) ToGetStackShowcaseArrayOutput() GetStackShowcaseArrayOutput { +func (o GetStacksWorkerPoolOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetStacksWorkerPool) []string { return v.AnyOfs }).(pulumi.StringArrayOutput) +} + +type GetStacksWorkerPoolPtrOutput struct{ *pulumi.OutputState } + +func (GetStacksWorkerPoolPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetStacksWorkerPool)(nil)).Elem() +} + +func (o GetStacksWorkerPoolPtrOutput) ToGetStacksWorkerPoolPtrOutput() GetStacksWorkerPoolPtrOutput { return o } -func (o GetStackShowcaseArrayOutput) ToGetStackShowcaseArrayOutputWithContext(ctx context.Context) GetStackShowcaseArrayOutput { +func (o GetStacksWorkerPoolPtrOutput) ToGetStacksWorkerPoolPtrOutputWithContext(ctx context.Context) GetStacksWorkerPoolPtrOutput { return o } -func (o GetStackShowcaseArrayOutput) Index(i pulumi.IntInput) GetStackShowcaseOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetStackShowcase { - return vs[0].([]GetStackShowcase)[vs[1].(int)] - }).(GetStackShowcaseOutput) +func (o GetStacksWorkerPoolPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*GetStacksWorkerPool] { + return pulumix.Output[*GetStacksWorkerPool]{ + OutputState: o.OutputState, + } +} + +func (o GetStacksWorkerPoolPtrOutput) Elem() GetStacksWorkerPoolOutput { + return o.ApplyT(func(v *GetStacksWorkerPool) GetStacksWorkerPool { + if v != nil { + return *v + } + var ret GetStacksWorkerPool + return ret + }).(GetStacksWorkerPoolOutput) +} + +func (o GetStacksWorkerPoolPtrOutput) AnyOfs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *GetStacksWorkerPool) []string { + if v == nil { + return nil + } + return v.AnyOfs + }).(pulumi.StringArrayOutput) } type GetVcsAgentPoolsVcsAgentPool struct { @@ -3733,6 +9409,12 @@ func (i GetVcsAgentPoolsVcsAgentPoolArgs) ToGetVcsAgentPoolsVcsAgentPoolOutputWi return pulumi.ToOutputWithContext(ctx, i).(GetVcsAgentPoolsVcsAgentPoolOutput) } +func (i GetVcsAgentPoolsVcsAgentPoolArgs) ToOutput(ctx context.Context) pulumix.Output[GetVcsAgentPoolsVcsAgentPool] { + return pulumix.Output[GetVcsAgentPoolsVcsAgentPool]{ + OutputState: i.ToGetVcsAgentPoolsVcsAgentPoolOutputWithContext(ctx).OutputState, + } +} + // GetVcsAgentPoolsVcsAgentPoolArrayInput is an input type that accepts GetVcsAgentPoolsVcsAgentPoolArray and GetVcsAgentPoolsVcsAgentPoolArrayOutput values. // You can construct a concrete instance of `GetVcsAgentPoolsVcsAgentPoolArrayInput` via: // @@ -3758,6 +9440,12 @@ func (i GetVcsAgentPoolsVcsAgentPoolArray) ToGetVcsAgentPoolsVcsAgentPoolArrayOu return pulumi.ToOutputWithContext(ctx, i).(GetVcsAgentPoolsVcsAgentPoolArrayOutput) } +func (i GetVcsAgentPoolsVcsAgentPoolArray) ToOutput(ctx context.Context) pulumix.Output[[]GetVcsAgentPoolsVcsAgentPool] { + return pulumix.Output[[]GetVcsAgentPoolsVcsAgentPool]{ + OutputState: i.ToGetVcsAgentPoolsVcsAgentPoolArrayOutputWithContext(ctx).OutputState, + } +} + type GetVcsAgentPoolsVcsAgentPoolOutput struct{ *pulumi.OutputState } func (GetVcsAgentPoolsVcsAgentPoolOutput) ElementType() reflect.Type { @@ -3772,6 +9460,12 @@ func (o GetVcsAgentPoolsVcsAgentPoolOutput) ToGetVcsAgentPoolsVcsAgentPoolOutput return o } +func (o GetVcsAgentPoolsVcsAgentPoolOutput) ToOutput(ctx context.Context) pulumix.Output[GetVcsAgentPoolsVcsAgentPool] { + return pulumix.Output[GetVcsAgentPoolsVcsAgentPool]{ + OutputState: o.OutputState, + } +} + func (o GetVcsAgentPoolsVcsAgentPoolOutput) Description() pulumi.StringOutput { return o.ApplyT(func(v GetVcsAgentPoolsVcsAgentPool) string { return v.Description }).(pulumi.StringOutput) } @@ -3798,6 +9492,12 @@ func (o GetVcsAgentPoolsVcsAgentPoolArrayOutput) ToGetVcsAgentPoolsVcsAgentPoolA return o } +func (o GetVcsAgentPoolsVcsAgentPoolArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetVcsAgentPoolsVcsAgentPool] { + return pulumix.Output[[]GetVcsAgentPoolsVcsAgentPool]{ + OutputState: o.OutputState, + } +} + func (o GetVcsAgentPoolsVcsAgentPoolArrayOutput) Index(i pulumi.IntInput) GetVcsAgentPoolsVcsAgentPoolOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetVcsAgentPoolsVcsAgentPool { return vs[0].([]GetVcsAgentPoolsVcsAgentPool)[vs[1].(int)] @@ -3843,6 +9543,12 @@ func (i GetWorkerPoolsWorkerPoolArgs) ToGetWorkerPoolsWorkerPoolOutputWithContex return pulumi.ToOutputWithContext(ctx, i).(GetWorkerPoolsWorkerPoolOutput) } +func (i GetWorkerPoolsWorkerPoolArgs) ToOutput(ctx context.Context) pulumix.Output[GetWorkerPoolsWorkerPool] { + return pulumix.Output[GetWorkerPoolsWorkerPool]{ + OutputState: i.ToGetWorkerPoolsWorkerPoolOutputWithContext(ctx).OutputState, + } +} + // GetWorkerPoolsWorkerPoolArrayInput is an input type that accepts GetWorkerPoolsWorkerPoolArray and GetWorkerPoolsWorkerPoolArrayOutput values. // You can construct a concrete instance of `GetWorkerPoolsWorkerPoolArrayInput` via: // @@ -3868,6 +9574,12 @@ func (i GetWorkerPoolsWorkerPoolArray) ToGetWorkerPoolsWorkerPoolArrayOutputWith return pulumi.ToOutputWithContext(ctx, i).(GetWorkerPoolsWorkerPoolArrayOutput) } +func (i GetWorkerPoolsWorkerPoolArray) ToOutput(ctx context.Context) pulumix.Output[[]GetWorkerPoolsWorkerPool] { + return pulumix.Output[[]GetWorkerPoolsWorkerPool]{ + OutputState: i.ToGetWorkerPoolsWorkerPoolArrayOutputWithContext(ctx).OutputState, + } +} + type GetWorkerPoolsWorkerPoolOutput struct{ *pulumi.OutputState } func (GetWorkerPoolsWorkerPoolOutput) ElementType() reflect.Type { @@ -3882,6 +9594,12 @@ func (o GetWorkerPoolsWorkerPoolOutput) ToGetWorkerPoolsWorkerPoolOutputWithCont return o } +func (o GetWorkerPoolsWorkerPoolOutput) ToOutput(ctx context.Context) pulumix.Output[GetWorkerPoolsWorkerPool] { + return pulumix.Output[GetWorkerPoolsWorkerPool]{ + OutputState: o.OutputState, + } +} + func (o GetWorkerPoolsWorkerPoolOutput) Config() pulumi.StringOutput { return o.ApplyT(func(v GetWorkerPoolsWorkerPool) string { return v.Config }).(pulumi.StringOutput) } @@ -3916,6 +9634,12 @@ func (o GetWorkerPoolsWorkerPoolArrayOutput) ToGetWorkerPoolsWorkerPoolArrayOutp return o } +func (o GetWorkerPoolsWorkerPoolArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]GetWorkerPoolsWorkerPool] { + return pulumix.Output[[]GetWorkerPoolsWorkerPool]{ + OutputState: o.OutputState, + } +} + func (o GetWorkerPoolsWorkerPoolArrayOutput) Index(i pulumi.IntInput) GetWorkerPoolsWorkerPoolOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetWorkerPoolsWorkerPool { return vs[0].([]GetWorkerPoolsWorkerPool)[vs[1].(int)] @@ -3923,6 +9647,8 @@ func (o GetWorkerPoolsWorkerPoolArrayOutput) Index(i pulumi.IntInput) GetWorkerP } func init() { + pulumi.RegisterInputType(reflect.TypeOf((*IdpGroupMappingPolicyInput)(nil)).Elem(), IdpGroupMappingPolicyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*IdpGroupMappingPolicyArrayInput)(nil)).Elem(), IdpGroupMappingPolicyArray{}) pulumi.RegisterInputType(reflect.TypeOf((*ModuleAzureDevopsInput)(nil)).Elem(), ModuleAzureDevopsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*ModuleAzureDevopsPtrInput)(nil)).Elem(), ModuleAzureDevopsArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*ModuleBitbucketCloudInput)(nil)).Elem(), ModuleBitbucketCloudArgs{}) @@ -3951,8 +9677,22 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*StackKubernetesPtrInput)(nil)).Elem(), StackKubernetesArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*StackPulumiInput)(nil)).Elem(), StackPulumiArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*StackPulumiPtrInput)(nil)).Elem(), StackPulumiArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackRawGitInput)(nil)).Elem(), StackRawGitArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackRawGitPtrInput)(nil)).Elem(), StackRawGitArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*StackShowcaseInput)(nil)).Elem(), StackShowcaseArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*StackShowcasePtrInput)(nil)).Elem(), StackShowcaseArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackTerragruntInput)(nil)).Elem(), StackTerragruntArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackTerragruntPtrInput)(nil)).Elem(), StackTerragruntArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserPolicyInput)(nil)).Elem(), UserPolicyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserPolicyArrayInput)(nil)).Elem(), UserPolicyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetAwsIntegrationsIntegrationInput)(nil)).Elem(), GetAwsIntegrationsIntegrationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetAwsIntegrationsIntegrationArrayInput)(nil)).Elem(), GetAwsIntegrationsIntegrationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetAzureIntegrationsIntegrationInput)(nil)).Elem(), GetAzureIntegrationsIntegrationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetAzureIntegrationsIntegrationArrayInput)(nil)).Elem(), GetAzureIntegrationsIntegrationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetContextsContextInput)(nil)).Elem(), GetContextsContextArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetContextsContextArrayInput)(nil)).Elem(), GetContextsContextArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetContextsLabelInput)(nil)).Elem(), GetContextsLabelArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetContextsLabelArrayInput)(nil)).Elem(), GetContextsLabelArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetModuleAzureDevopInput)(nil)).Elem(), GetModuleAzureDevopArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetModuleAzureDevopArrayInput)(nil)).Elem(), GetModuleAzureDevopArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetModuleBitbucketCloudInput)(nil)).Elem(), GetModuleBitbucketCloudArgs{}) @@ -3965,6 +9705,8 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*GetModuleGitlabArrayInput)(nil)).Elem(), GetModuleGitlabArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetPoliciesPolicyInput)(nil)).Elem(), GetPoliciesPolicyArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetPoliciesPolicyArrayInput)(nil)).Elem(), GetPoliciesPolicyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSpacesSpaceInput)(nil)).Elem(), GetSpacesSpaceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSpacesSpaceArrayInput)(nil)).Elem(), GetSpacesSpaceArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetStackAnsibleInput)(nil)).Elem(), GetStackAnsibleArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetStackAnsibleArrayInput)(nil)).Elem(), GetStackAnsibleArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetStackAzureDevopInput)(nil)).Elem(), GetStackAzureDevopArgs{}) @@ -3983,12 +9725,62 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*GetStackKuberneteArrayInput)(nil)).Elem(), GetStackKuberneteArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetStackPulumiInput)(nil)).Elem(), GetStackPulumiArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetStackPulumiArrayInput)(nil)).Elem(), GetStackPulumiArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStackRawGitInput)(nil)).Elem(), GetStackRawGitArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStackRawGitArrayInput)(nil)).Elem(), GetStackRawGitArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetStackShowcaseInput)(nil)).Elem(), GetStackShowcaseArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetStackShowcaseArrayInput)(nil)).Elem(), GetStackShowcaseArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksAdministrativeInput)(nil)).Elem(), GetStacksAdministrativeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksAdministrativePtrInput)(nil)).Elem(), GetStacksAdministrativeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksBranchInput)(nil)).Elem(), GetStacksBranchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksBranchPtrInput)(nil)).Elem(), GetStacksBranchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksCommitInput)(nil)).Elem(), GetStacksCommitArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksCommitPtrInput)(nil)).Elem(), GetStacksCommitArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksLabelInput)(nil)).Elem(), GetStacksLabelArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksLabelArrayInput)(nil)).Elem(), GetStacksLabelArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksLockedInput)(nil)).Elem(), GetStacksLockedArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksLockedPtrInput)(nil)).Elem(), GetStacksLockedArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksNameInput)(nil)).Elem(), GetStacksNameArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksNamePtrInput)(nil)).Elem(), GetStacksNameArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksProjectRootInput)(nil)).Elem(), GetStacksProjectRootArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksProjectRootPtrInput)(nil)).Elem(), GetStacksProjectRootArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksRepositoryInput)(nil)).Elem(), GetStacksRepositoryArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksRepositoryPtrInput)(nil)).Elem(), GetStacksRepositoryArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackInput)(nil)).Elem(), GetStacksStackArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackArrayInput)(nil)).Elem(), GetStacksStackArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackAnsibleInput)(nil)).Elem(), GetStacksStackAnsibleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackAnsibleArrayInput)(nil)).Elem(), GetStacksStackAnsibleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackAzureDevopInput)(nil)).Elem(), GetStacksStackAzureDevopArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackAzureDevopArrayInput)(nil)).Elem(), GetStacksStackAzureDevopArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackBitbucketCloudInput)(nil)).Elem(), GetStacksStackBitbucketCloudArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackBitbucketCloudArrayInput)(nil)).Elem(), GetStacksStackBitbucketCloudArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackBitbucketDatacenterInput)(nil)).Elem(), GetStacksStackBitbucketDatacenterArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackBitbucketDatacenterArrayInput)(nil)).Elem(), GetStacksStackBitbucketDatacenterArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackCloudformationInput)(nil)).Elem(), GetStacksStackCloudformationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackCloudformationArrayInput)(nil)).Elem(), GetStacksStackCloudformationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackGithubEnterpriseInput)(nil)).Elem(), GetStacksStackGithubEnterpriseArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackGithubEnterpriseArrayInput)(nil)).Elem(), GetStacksStackGithubEnterpriseArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackGitlabInput)(nil)).Elem(), GetStacksStackGitlabArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackGitlabArrayInput)(nil)).Elem(), GetStacksStackGitlabArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackKuberneteInput)(nil)).Elem(), GetStacksStackKuberneteArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackKuberneteArrayInput)(nil)).Elem(), GetStacksStackKuberneteArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackPulumiInput)(nil)).Elem(), GetStacksStackPulumiArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackPulumiArrayInput)(nil)).Elem(), GetStacksStackPulumiArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackRawGitInput)(nil)).Elem(), GetStacksStackRawGitArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackRawGitArrayInput)(nil)).Elem(), GetStacksStackRawGitArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackShowcaseInput)(nil)).Elem(), GetStacksStackShowcaseArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStackShowcaseArrayInput)(nil)).Elem(), GetStacksStackShowcaseArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStateInput)(nil)).Elem(), GetStacksStateArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksStatePtrInput)(nil)).Elem(), GetStacksStateArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksVendorInput)(nil)).Elem(), GetStacksVendorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksVendorPtrInput)(nil)).Elem(), GetStacksVendorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksWorkerPoolInput)(nil)).Elem(), GetStacksWorkerPoolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetStacksWorkerPoolPtrInput)(nil)).Elem(), GetStacksWorkerPoolArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetVcsAgentPoolsVcsAgentPoolInput)(nil)).Elem(), GetVcsAgentPoolsVcsAgentPoolArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetVcsAgentPoolsVcsAgentPoolArrayInput)(nil)).Elem(), GetVcsAgentPoolsVcsAgentPoolArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetWorkerPoolsWorkerPoolInput)(nil)).Elem(), GetWorkerPoolsWorkerPoolArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetWorkerPoolsWorkerPoolArrayInput)(nil)).Elem(), GetWorkerPoolsWorkerPoolArray{}) + pulumi.RegisterOutputType(IdpGroupMappingPolicyOutput{}) + pulumi.RegisterOutputType(IdpGroupMappingPolicyArrayOutput{}) pulumi.RegisterOutputType(ModuleAzureDevopsOutput{}) pulumi.RegisterOutputType(ModuleAzureDevopsPtrOutput{}) pulumi.RegisterOutputType(ModuleBitbucketCloudOutput{}) @@ -4017,8 +9809,22 @@ func init() { pulumi.RegisterOutputType(StackKubernetesPtrOutput{}) pulumi.RegisterOutputType(StackPulumiOutput{}) pulumi.RegisterOutputType(StackPulumiPtrOutput{}) + pulumi.RegisterOutputType(StackRawGitOutput{}) + pulumi.RegisterOutputType(StackRawGitPtrOutput{}) pulumi.RegisterOutputType(StackShowcaseOutput{}) pulumi.RegisterOutputType(StackShowcasePtrOutput{}) + pulumi.RegisterOutputType(StackTerragruntOutput{}) + pulumi.RegisterOutputType(StackTerragruntPtrOutput{}) + pulumi.RegisterOutputType(UserPolicyOutput{}) + pulumi.RegisterOutputType(UserPolicyArrayOutput{}) + pulumi.RegisterOutputType(GetAwsIntegrationsIntegrationOutput{}) + pulumi.RegisterOutputType(GetAwsIntegrationsIntegrationArrayOutput{}) + pulumi.RegisterOutputType(GetAzureIntegrationsIntegrationOutput{}) + pulumi.RegisterOutputType(GetAzureIntegrationsIntegrationArrayOutput{}) + pulumi.RegisterOutputType(GetContextsContextOutput{}) + pulumi.RegisterOutputType(GetContextsContextArrayOutput{}) + pulumi.RegisterOutputType(GetContextsLabelOutput{}) + pulumi.RegisterOutputType(GetContextsLabelArrayOutput{}) pulumi.RegisterOutputType(GetModuleAzureDevopOutput{}) pulumi.RegisterOutputType(GetModuleAzureDevopArrayOutput{}) pulumi.RegisterOutputType(GetModuleBitbucketCloudOutput{}) @@ -4031,6 +9837,8 @@ func init() { pulumi.RegisterOutputType(GetModuleGitlabArrayOutput{}) pulumi.RegisterOutputType(GetPoliciesPolicyOutput{}) pulumi.RegisterOutputType(GetPoliciesPolicyArrayOutput{}) + pulumi.RegisterOutputType(GetSpacesSpaceOutput{}) + pulumi.RegisterOutputType(GetSpacesSpaceArrayOutput{}) pulumi.RegisterOutputType(GetStackAnsibleOutput{}) pulumi.RegisterOutputType(GetStackAnsibleArrayOutput{}) pulumi.RegisterOutputType(GetStackAzureDevopOutput{}) @@ -4049,8 +9857,56 @@ func init() { pulumi.RegisterOutputType(GetStackKuberneteArrayOutput{}) pulumi.RegisterOutputType(GetStackPulumiOutput{}) pulumi.RegisterOutputType(GetStackPulumiArrayOutput{}) + pulumi.RegisterOutputType(GetStackRawGitOutput{}) + pulumi.RegisterOutputType(GetStackRawGitArrayOutput{}) pulumi.RegisterOutputType(GetStackShowcaseOutput{}) pulumi.RegisterOutputType(GetStackShowcaseArrayOutput{}) + pulumi.RegisterOutputType(GetStacksAdministrativeOutput{}) + pulumi.RegisterOutputType(GetStacksAdministrativePtrOutput{}) + pulumi.RegisterOutputType(GetStacksBranchOutput{}) + pulumi.RegisterOutputType(GetStacksBranchPtrOutput{}) + pulumi.RegisterOutputType(GetStacksCommitOutput{}) + pulumi.RegisterOutputType(GetStacksCommitPtrOutput{}) + pulumi.RegisterOutputType(GetStacksLabelOutput{}) + pulumi.RegisterOutputType(GetStacksLabelArrayOutput{}) + pulumi.RegisterOutputType(GetStacksLockedOutput{}) + pulumi.RegisterOutputType(GetStacksLockedPtrOutput{}) + pulumi.RegisterOutputType(GetStacksNameOutput{}) + pulumi.RegisterOutputType(GetStacksNamePtrOutput{}) + pulumi.RegisterOutputType(GetStacksProjectRootOutput{}) + pulumi.RegisterOutputType(GetStacksProjectRootPtrOutput{}) + pulumi.RegisterOutputType(GetStacksRepositoryOutput{}) + pulumi.RegisterOutputType(GetStacksRepositoryPtrOutput{}) + pulumi.RegisterOutputType(GetStacksStackOutput{}) + pulumi.RegisterOutputType(GetStacksStackArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackAnsibleOutput{}) + pulumi.RegisterOutputType(GetStacksStackAnsibleArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackAzureDevopOutput{}) + pulumi.RegisterOutputType(GetStacksStackAzureDevopArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackBitbucketCloudOutput{}) + pulumi.RegisterOutputType(GetStacksStackBitbucketCloudArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackBitbucketDatacenterOutput{}) + pulumi.RegisterOutputType(GetStacksStackBitbucketDatacenterArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackCloudformationOutput{}) + pulumi.RegisterOutputType(GetStacksStackCloudformationArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackGithubEnterpriseOutput{}) + pulumi.RegisterOutputType(GetStacksStackGithubEnterpriseArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackGitlabOutput{}) + pulumi.RegisterOutputType(GetStacksStackGitlabArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackKuberneteOutput{}) + pulumi.RegisterOutputType(GetStacksStackKuberneteArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackPulumiOutput{}) + pulumi.RegisterOutputType(GetStacksStackPulumiArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackRawGitOutput{}) + pulumi.RegisterOutputType(GetStacksStackRawGitArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStackShowcaseOutput{}) + pulumi.RegisterOutputType(GetStacksStackShowcaseArrayOutput{}) + pulumi.RegisterOutputType(GetStacksStateOutput{}) + pulumi.RegisterOutputType(GetStacksStatePtrOutput{}) + pulumi.RegisterOutputType(GetStacksVendorOutput{}) + pulumi.RegisterOutputType(GetStacksVendorPtrOutput{}) + pulumi.RegisterOutputType(GetStacksWorkerPoolOutput{}) + pulumi.RegisterOutputType(GetStacksWorkerPoolPtrOutput{}) pulumi.RegisterOutputType(GetVcsAgentPoolsVcsAgentPoolOutput{}) pulumi.RegisterOutputType(GetVcsAgentPoolsVcsAgentPoolArrayOutput{}) pulumi.RegisterOutputType(GetWorkerPoolsWorkerPoolOutput{}) diff --git a/sdk/go/spacelift/pulumiUtilities.go b/sdk/go/spacelift/pulumiUtilities.go deleted file mode 100644 index bdb11bb..0000000 --- a/sdk/go/spacelift/pulumiUtilities.go +++ /dev/null @@ -1,101 +0,0 @@ -// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. -// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** - -package spacelift - -import ( - "fmt" - "os" - "reflect" - "regexp" - "strconv" - "strings" - - "github.com/blang/semver" - "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -) - -type envParser func(v string) interface{} - -func parseEnvBool(v string) interface{} { - b, err := strconv.ParseBool(v) - if err != nil { - return nil - } - return b -} - -func parseEnvInt(v string) interface{} { - i, err := strconv.ParseInt(v, 0, 0) - if err != nil { - return nil - } - return int(i) -} - -func parseEnvFloat(v string) interface{} { - f, err := strconv.ParseFloat(v, 64) - if err != nil { - return nil - } - return f -} - -func parseEnvStringArray(v string) interface{} { - var result pulumi.StringArray - for _, item := range strings.Split(v, ";") { - result = append(result, pulumi.String(item)) - } - return result -} - -func getEnvOrDefault(def interface{}, parser envParser, vars ...string) interface{} { - for _, v := range vars { - if value := os.Getenv(v); value != "" { - if parser != nil { - return parser(value) - } - return value - } - } - return def -} - -// PkgVersion uses reflection to determine the version of the current package. -// If a version cannot be determined, v1 will be assumed. The second return -// value is always nil. -func PkgVersion() (semver.Version, error) { - type sentinal struct{} - pkgPath := reflect.TypeOf(sentinal{}).PkgPath() - re := regexp.MustCompile("^.*/pulumi-spacelift/sdk(/v\\d+)?") - if match := re.FindStringSubmatch(pkgPath); match != nil { - vStr := match[1] - if len(vStr) == 0 { // If the version capture group was empty, default to v1. - return semver.Version{Major: 1}, nil - } - return semver.MustParse(fmt.Sprintf("%s.0.0", vStr[2:])), nil - } - return semver.Version{Major: 1}, nil -} - -// isZero is a null safe check for if a value is it's types zero value. -func isZero(v interface{}) bool { - if v == nil { - return true - } - return reflect.ValueOf(v).IsZero() -} - -// pkgResourceDefaultOpts provides package level defaults to pulumi.OptionResource. -func pkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption { - defaults := []pulumi.ResourceOption{pulumi.PluginDownloadURL("https://downloads.spacelift.io/pulumi-plugins")} - - return append(defaults, opts...) -} - -// pkgInvokeDefaultOpts provides package level defaults to pulumi.OptionInvoke. -func pkgInvokeDefaultOpts(opts []pulumi.InvokeOption) []pulumi.InvokeOption { - defaults := []pulumi.InvokeOption{pulumi.PluginDownloadURL("https://downloads.spacelift.io/pulumi-plugins")} - - return append(defaults, opts...) -} diff --git a/sdk/go/spacelift/run.go b/sdk/go/spacelift/run.go index c7ebfaf..e61b02f 100644 --- a/sdk/go/spacelift/run.go +++ b/sdk/go/spacelift/run.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Run` allows programmatically triggering runs in response to arbitrary changes in the keepers section. @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -36,7 +38,7 @@ import ( // } // _, err = spacelift.NewRun(ctx, "thisRun", &spacelift.RunArgs{ // StackId: thisStack.ID(), -// Keepers: pulumi.AnyMap{ +// Keepers: pulumi.Map{ // "branch": thisStack.Branch, // }, // }) @@ -71,7 +73,7 @@ func NewRun(ctx *pulumi.Context, if args.StackId == nil { return nil, errors.New("invalid value for required argument 'StackId'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource Run err := ctx.RegisterResource("spacelift:index/run:Run", name, args, &resource, opts...) if err != nil { @@ -165,6 +167,12 @@ func (i *Run) ToRunOutputWithContext(ctx context.Context) RunOutput { return pulumi.ToOutputWithContext(ctx, i).(RunOutput) } +func (i *Run) ToOutput(ctx context.Context) pulumix.Output[*Run] { + return pulumix.Output[*Run]{ + OutputState: i.ToRunOutputWithContext(ctx).OutputState, + } +} + // RunArrayInput is an input type that accepts RunArray and RunArrayOutput values. // You can construct a concrete instance of `RunArrayInput` via: // @@ -190,6 +198,12 @@ func (i RunArray) ToRunArrayOutputWithContext(ctx context.Context) RunArrayOutpu return pulumi.ToOutputWithContext(ctx, i).(RunArrayOutput) } +func (i RunArray) ToOutput(ctx context.Context) pulumix.Output[[]*Run] { + return pulumix.Output[[]*Run]{ + OutputState: i.ToRunArrayOutputWithContext(ctx).OutputState, + } +} + // RunMapInput is an input type that accepts RunMap and RunMapOutput values. // You can construct a concrete instance of `RunMapInput` via: // @@ -215,6 +229,12 @@ func (i RunMap) ToRunMapOutputWithContext(ctx context.Context) RunMapOutput { return pulumi.ToOutputWithContext(ctx, i).(RunMapOutput) } +func (i RunMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Run] { + return pulumix.Output[map[string]*Run]{ + OutputState: i.ToRunMapOutputWithContext(ctx).OutputState, + } +} + type RunOutput struct{ *pulumi.OutputState } func (RunOutput) ElementType() reflect.Type { @@ -229,6 +249,12 @@ func (o RunOutput) ToRunOutputWithContext(ctx context.Context) RunOutput { return o } +func (o RunOutput) ToOutput(ctx context.Context) pulumix.Output[*Run] { + return pulumix.Output[*Run]{ + OutputState: o.OutputState, + } +} + // The commit SHA for which to trigger a run. func (o RunOutput) CommitSha() pulumi.StringPtrOutput { return o.ApplyT(func(v *Run) pulumi.StringPtrOutput { return v.CommitSha }).(pulumi.StringPtrOutput) @@ -263,6 +289,12 @@ func (o RunArrayOutput) ToRunArrayOutputWithContext(ctx context.Context) RunArra return o } +func (o RunArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Run] { + return pulumix.Output[[]*Run]{ + OutputState: o.OutputState, + } +} + func (o RunArrayOutput) Index(i pulumi.IntInput) RunOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Run { return vs[0].([]*Run)[vs[1].(int)] @@ -283,6 +315,12 @@ func (o RunMapOutput) ToRunMapOutputWithContext(ctx context.Context) RunMapOutpu return o } +func (o RunMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Run] { + return pulumix.Output[map[string]*Run]{ + OutputState: o.OutputState, + } +} + func (o RunMapOutput) MapIndex(k pulumi.StringInput) RunOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Run { return vs[0].(map[string]*Run)[vs[1].(string)] diff --git a/sdk/go/spacelift/scheduledDeleteTask.go b/sdk/go/spacelift/scheduledDeleteTask.go new file mode 100644 index 0000000..e74b769 --- /dev/null +++ b/sdk/go/spacelift/scheduledDeleteTask.go @@ -0,0 +1,344 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := spacelift.NewStack(ctx, "k8s-core", nil) +// if err != nil { +// return err +// } +// _, err = spacelift.NewScheduledDeleteTask(ctx, "k8s-core-delete", &spacelift.ScheduledDeleteTaskArgs{ +// StackId: k8s_core.ID(), +// At: pulumi.Int(1663336895), +// DeleteResources: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// ```sh +// +// $ pulumi import spacelift:index/scheduledDeleteTask:ScheduledDeleteTask ireland-kubeconfig $STACK_ID/$SCHEDULED_DELETE_STACK_ID +// +// ``` +type ScheduledDeleteTask struct { + pulumi.CustomResourceState + + // Timestamp (unix timestamp) at which time the scheduling should happen. + At pulumi.IntOutput `pulumi:"at"` + // Indicates whether the resources of the stack should be deleted. + DeleteResources pulumi.BoolPtrOutput `pulumi:"deleteResources"` + // ID of the schedule + ScheduleId pulumi.StringOutput `pulumi:"scheduleId"` + // ID of the stack for which to set up scheduling + StackId pulumi.StringOutput `pulumi:"stackId"` +} + +// NewScheduledDeleteTask registers a new resource with the given unique name, arguments, and options. +func NewScheduledDeleteTask(ctx *pulumi.Context, + name string, args *ScheduledDeleteTaskArgs, opts ...pulumi.ResourceOption) (*ScheduledDeleteTask, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.At == nil { + return nil, errors.New("invalid value for required argument 'At'") + } + if args.StackId == nil { + return nil, errors.New("invalid value for required argument 'StackId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ScheduledDeleteTask + err := ctx.RegisterResource("spacelift:index/scheduledDeleteTask:ScheduledDeleteTask", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetScheduledDeleteTask gets an existing ScheduledDeleteTask resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetScheduledDeleteTask(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ScheduledDeleteTaskState, opts ...pulumi.ResourceOption) (*ScheduledDeleteTask, error) { + var resource ScheduledDeleteTask + err := ctx.ReadResource("spacelift:index/scheduledDeleteTask:ScheduledDeleteTask", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ScheduledDeleteTask resources. +type scheduledDeleteTaskState struct { + // Timestamp (unix timestamp) at which time the scheduling should happen. + At *int `pulumi:"at"` + // Indicates whether the resources of the stack should be deleted. + DeleteResources *bool `pulumi:"deleteResources"` + // ID of the schedule + ScheduleId *string `pulumi:"scheduleId"` + // ID of the stack for which to set up scheduling + StackId *string `pulumi:"stackId"` +} + +type ScheduledDeleteTaskState struct { + // Timestamp (unix timestamp) at which time the scheduling should happen. + At pulumi.IntPtrInput + // Indicates whether the resources of the stack should be deleted. + DeleteResources pulumi.BoolPtrInput + // ID of the schedule + ScheduleId pulumi.StringPtrInput + // ID of the stack for which to set up scheduling + StackId pulumi.StringPtrInput +} + +func (ScheduledDeleteTaskState) ElementType() reflect.Type { + return reflect.TypeOf((*scheduledDeleteTaskState)(nil)).Elem() +} + +type scheduledDeleteTaskArgs struct { + // Timestamp (unix timestamp) at which time the scheduling should happen. + At int `pulumi:"at"` + // Indicates whether the resources of the stack should be deleted. + DeleteResources *bool `pulumi:"deleteResources"` + // ID of the schedule + ScheduleId *string `pulumi:"scheduleId"` + // ID of the stack for which to set up scheduling + StackId string `pulumi:"stackId"` +} + +// The set of arguments for constructing a ScheduledDeleteTask resource. +type ScheduledDeleteTaskArgs struct { + // Timestamp (unix timestamp) at which time the scheduling should happen. + At pulumi.IntInput + // Indicates whether the resources of the stack should be deleted. + DeleteResources pulumi.BoolPtrInput + // ID of the schedule + ScheduleId pulumi.StringPtrInput + // ID of the stack for which to set up scheduling + StackId pulumi.StringInput +} + +func (ScheduledDeleteTaskArgs) ElementType() reflect.Type { + return reflect.TypeOf((*scheduledDeleteTaskArgs)(nil)).Elem() +} + +type ScheduledDeleteTaskInput interface { + pulumi.Input + + ToScheduledDeleteTaskOutput() ScheduledDeleteTaskOutput + ToScheduledDeleteTaskOutputWithContext(ctx context.Context) ScheduledDeleteTaskOutput +} + +func (*ScheduledDeleteTask) ElementType() reflect.Type { + return reflect.TypeOf((**ScheduledDeleteTask)(nil)).Elem() +} + +func (i *ScheduledDeleteTask) ToScheduledDeleteTaskOutput() ScheduledDeleteTaskOutput { + return i.ToScheduledDeleteTaskOutputWithContext(context.Background()) +} + +func (i *ScheduledDeleteTask) ToScheduledDeleteTaskOutputWithContext(ctx context.Context) ScheduledDeleteTaskOutput { + return pulumi.ToOutputWithContext(ctx, i).(ScheduledDeleteTaskOutput) +} + +func (i *ScheduledDeleteTask) ToOutput(ctx context.Context) pulumix.Output[*ScheduledDeleteTask] { + return pulumix.Output[*ScheduledDeleteTask]{ + OutputState: i.ToScheduledDeleteTaskOutputWithContext(ctx).OutputState, + } +} + +// ScheduledDeleteTaskArrayInput is an input type that accepts ScheduledDeleteTaskArray and ScheduledDeleteTaskArrayOutput values. +// You can construct a concrete instance of `ScheduledDeleteTaskArrayInput` via: +// +// ScheduledDeleteTaskArray{ ScheduledDeleteTaskArgs{...} } +type ScheduledDeleteTaskArrayInput interface { + pulumi.Input + + ToScheduledDeleteTaskArrayOutput() ScheduledDeleteTaskArrayOutput + ToScheduledDeleteTaskArrayOutputWithContext(context.Context) ScheduledDeleteTaskArrayOutput +} + +type ScheduledDeleteTaskArray []ScheduledDeleteTaskInput + +func (ScheduledDeleteTaskArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ScheduledDeleteTask)(nil)).Elem() +} + +func (i ScheduledDeleteTaskArray) ToScheduledDeleteTaskArrayOutput() ScheduledDeleteTaskArrayOutput { + return i.ToScheduledDeleteTaskArrayOutputWithContext(context.Background()) +} + +func (i ScheduledDeleteTaskArray) ToScheduledDeleteTaskArrayOutputWithContext(ctx context.Context) ScheduledDeleteTaskArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ScheduledDeleteTaskArrayOutput) +} + +func (i ScheduledDeleteTaskArray) ToOutput(ctx context.Context) pulumix.Output[[]*ScheduledDeleteTask] { + return pulumix.Output[[]*ScheduledDeleteTask]{ + OutputState: i.ToScheduledDeleteTaskArrayOutputWithContext(ctx).OutputState, + } +} + +// ScheduledDeleteTaskMapInput is an input type that accepts ScheduledDeleteTaskMap and ScheduledDeleteTaskMapOutput values. +// You can construct a concrete instance of `ScheduledDeleteTaskMapInput` via: +// +// ScheduledDeleteTaskMap{ "key": ScheduledDeleteTaskArgs{...} } +type ScheduledDeleteTaskMapInput interface { + pulumi.Input + + ToScheduledDeleteTaskMapOutput() ScheduledDeleteTaskMapOutput + ToScheduledDeleteTaskMapOutputWithContext(context.Context) ScheduledDeleteTaskMapOutput +} + +type ScheduledDeleteTaskMap map[string]ScheduledDeleteTaskInput + +func (ScheduledDeleteTaskMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ScheduledDeleteTask)(nil)).Elem() +} + +func (i ScheduledDeleteTaskMap) ToScheduledDeleteTaskMapOutput() ScheduledDeleteTaskMapOutput { + return i.ToScheduledDeleteTaskMapOutputWithContext(context.Background()) +} + +func (i ScheduledDeleteTaskMap) ToScheduledDeleteTaskMapOutputWithContext(ctx context.Context) ScheduledDeleteTaskMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ScheduledDeleteTaskMapOutput) +} + +func (i ScheduledDeleteTaskMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ScheduledDeleteTask] { + return pulumix.Output[map[string]*ScheduledDeleteTask]{ + OutputState: i.ToScheduledDeleteTaskMapOutputWithContext(ctx).OutputState, + } +} + +type ScheduledDeleteTaskOutput struct{ *pulumi.OutputState } + +func (ScheduledDeleteTaskOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ScheduledDeleteTask)(nil)).Elem() +} + +func (o ScheduledDeleteTaskOutput) ToScheduledDeleteTaskOutput() ScheduledDeleteTaskOutput { + return o +} + +func (o ScheduledDeleteTaskOutput) ToScheduledDeleteTaskOutputWithContext(ctx context.Context) ScheduledDeleteTaskOutput { + return o +} + +func (o ScheduledDeleteTaskOutput) ToOutput(ctx context.Context) pulumix.Output[*ScheduledDeleteTask] { + return pulumix.Output[*ScheduledDeleteTask]{ + OutputState: o.OutputState, + } +} + +// Timestamp (unix timestamp) at which time the scheduling should happen. +func (o ScheduledDeleteTaskOutput) At() pulumi.IntOutput { + return o.ApplyT(func(v *ScheduledDeleteTask) pulumi.IntOutput { return v.At }).(pulumi.IntOutput) +} + +// Indicates whether the resources of the stack should be deleted. +func (o ScheduledDeleteTaskOutput) DeleteResources() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ScheduledDeleteTask) pulumi.BoolPtrOutput { return v.DeleteResources }).(pulumi.BoolPtrOutput) +} + +// ID of the schedule +func (o ScheduledDeleteTaskOutput) ScheduleId() pulumi.StringOutput { + return o.ApplyT(func(v *ScheduledDeleteTask) pulumi.StringOutput { return v.ScheduleId }).(pulumi.StringOutput) +} + +// ID of the stack for which to set up scheduling +func (o ScheduledDeleteTaskOutput) StackId() pulumi.StringOutput { + return o.ApplyT(func(v *ScheduledDeleteTask) pulumi.StringOutput { return v.StackId }).(pulumi.StringOutput) +} + +type ScheduledDeleteTaskArrayOutput struct{ *pulumi.OutputState } + +func (ScheduledDeleteTaskArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ScheduledDeleteTask)(nil)).Elem() +} + +func (o ScheduledDeleteTaskArrayOutput) ToScheduledDeleteTaskArrayOutput() ScheduledDeleteTaskArrayOutput { + return o +} + +func (o ScheduledDeleteTaskArrayOutput) ToScheduledDeleteTaskArrayOutputWithContext(ctx context.Context) ScheduledDeleteTaskArrayOutput { + return o +} + +func (o ScheduledDeleteTaskArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ScheduledDeleteTask] { + return pulumix.Output[[]*ScheduledDeleteTask]{ + OutputState: o.OutputState, + } +} + +func (o ScheduledDeleteTaskArrayOutput) Index(i pulumi.IntInput) ScheduledDeleteTaskOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ScheduledDeleteTask { + return vs[0].([]*ScheduledDeleteTask)[vs[1].(int)] + }).(ScheduledDeleteTaskOutput) +} + +type ScheduledDeleteTaskMapOutput struct{ *pulumi.OutputState } + +func (ScheduledDeleteTaskMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ScheduledDeleteTask)(nil)).Elem() +} + +func (o ScheduledDeleteTaskMapOutput) ToScheduledDeleteTaskMapOutput() ScheduledDeleteTaskMapOutput { + return o +} + +func (o ScheduledDeleteTaskMapOutput) ToScheduledDeleteTaskMapOutputWithContext(ctx context.Context) ScheduledDeleteTaskMapOutput { + return o +} + +func (o ScheduledDeleteTaskMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ScheduledDeleteTask] { + return pulumix.Output[map[string]*ScheduledDeleteTask]{ + OutputState: o.OutputState, + } +} + +func (o ScheduledDeleteTaskMapOutput) MapIndex(k pulumi.StringInput) ScheduledDeleteTaskOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ScheduledDeleteTask { + return vs[0].(map[string]*ScheduledDeleteTask)[vs[1].(string)] + }).(ScheduledDeleteTaskOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ScheduledDeleteTaskInput)(nil)).Elem(), &ScheduledDeleteTask{}) + pulumi.RegisterInputType(reflect.TypeOf((*ScheduledDeleteTaskArrayInput)(nil)).Elem(), ScheduledDeleteTaskArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ScheduledDeleteTaskMapInput)(nil)).Elem(), ScheduledDeleteTaskMap{}) + pulumi.RegisterOutputType(ScheduledDeleteTaskOutput{}) + pulumi.RegisterOutputType(ScheduledDeleteTaskArrayOutput{}) + pulumi.RegisterOutputType(ScheduledDeleteTaskMapOutput{}) +} diff --git a/sdk/go/spacelift/scheduledTask.go b/sdk/go/spacelift/scheduledTask.go new file mode 100644 index 0000000..0f1f26a --- /dev/null +++ b/sdk/go/spacelift/scheduledTask.go @@ -0,0 +1,396 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `ScheduledTask` represents a scheduling configuration for a Stack. It will trigger task on the given schedule or timestamp +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := spacelift.NewStack(ctx, "k8s-core", nil) +// if err != nil { +// return err +// } +// _, err = spacelift.NewScheduledTask(ctx, "k8s-core-create", &spacelift.ScheduledTaskArgs{ +// StackId: k8s_core.ID(), +// Command: pulumi.String("pulumi up -auto-approve"), +// Everies: pulumi.StringArray{ +// pulumi.String("0 7 * * 1-5"), +// }, +// Timezone: pulumi.String("CET"), +// }) +// if err != nil { +// return err +// } +// _, err = spacelift.NewScheduledTask(ctx, "k8s-core-destroyScheduledTask", &spacelift.ScheduledTaskArgs{ +// StackId: k8s_core.ID(), +// Command: pulumi.String("terraform destroy -auto-approve"), +// Everies: pulumi.StringArray{ +// pulumi.String("0 21 * * 1-5"), +// }, +// Timezone: pulumi.String("CET"), +// }) +// if err != nil { +// return err +// } +// _, err = spacelift.NewScheduledTask(ctx, "k8s-core-destroyIndex/scheduledTaskScheduledTask", &spacelift.ScheduledTaskArgs{ +// StackId: k8s_core.ID(), +// Command: pulumi.String("terraform destroy -auto-approve"), +// At: pulumi.Int(1663336895), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// ```sh +// +// $ pulumi import spacelift:index/scheduledTask:ScheduledTask ireland-kubeconfig $STACK_ID/$SCHEDULED_TASK_ID +// +// ``` +type ScheduledTask struct { + pulumi.CustomResourceState + + // Timestamp (unix timestamp) at which time the scheduled task should happen. + At pulumi.IntPtrOutput `pulumi:"at"` + // Command that will be run. + Command pulumi.StringOutput `pulumi:"command"` + // List of cron schedule expressions based on which the scheduled task should be triggered. + Everies pulumi.StringArrayOutput `pulumi:"everies"` + // ID of the schedule + ScheduleId pulumi.StringOutput `pulumi:"scheduleId"` + // ID of the stack for which to set up the scheduled task + StackId pulumi.StringOutput `pulumi:"stackId"` + // Timezone in which the schedule is expressed. Defaults to `UTC`. + Timezone pulumi.StringPtrOutput `pulumi:"timezone"` +} + +// NewScheduledTask registers a new resource with the given unique name, arguments, and options. +func NewScheduledTask(ctx *pulumi.Context, + name string, args *ScheduledTaskArgs, opts ...pulumi.ResourceOption) (*ScheduledTask, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Command == nil { + return nil, errors.New("invalid value for required argument 'Command'") + } + if args.StackId == nil { + return nil, errors.New("invalid value for required argument 'StackId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ScheduledTask + err := ctx.RegisterResource("spacelift:index/scheduledTask:ScheduledTask", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetScheduledTask gets an existing ScheduledTask resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetScheduledTask(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ScheduledTaskState, opts ...pulumi.ResourceOption) (*ScheduledTask, error) { + var resource ScheduledTask + err := ctx.ReadResource("spacelift:index/scheduledTask:ScheduledTask", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ScheduledTask resources. +type scheduledTaskState struct { + // Timestamp (unix timestamp) at which time the scheduled task should happen. + At *int `pulumi:"at"` + // Command that will be run. + Command *string `pulumi:"command"` + // List of cron schedule expressions based on which the scheduled task should be triggered. + Everies []string `pulumi:"everies"` + // ID of the schedule + ScheduleId *string `pulumi:"scheduleId"` + // ID of the stack for which to set up the scheduled task + StackId *string `pulumi:"stackId"` + // Timezone in which the schedule is expressed. Defaults to `UTC`. + Timezone *string `pulumi:"timezone"` +} + +type ScheduledTaskState struct { + // Timestamp (unix timestamp) at which time the scheduled task should happen. + At pulumi.IntPtrInput + // Command that will be run. + Command pulumi.StringPtrInput + // List of cron schedule expressions based on which the scheduled task should be triggered. + Everies pulumi.StringArrayInput + // ID of the schedule + ScheduleId pulumi.StringPtrInput + // ID of the stack for which to set up the scheduled task + StackId pulumi.StringPtrInput + // Timezone in which the schedule is expressed. Defaults to `UTC`. + Timezone pulumi.StringPtrInput +} + +func (ScheduledTaskState) ElementType() reflect.Type { + return reflect.TypeOf((*scheduledTaskState)(nil)).Elem() +} + +type scheduledTaskArgs struct { + // Timestamp (unix timestamp) at which time the scheduled task should happen. + At *int `pulumi:"at"` + // Command that will be run. + Command string `pulumi:"command"` + // List of cron schedule expressions based on which the scheduled task should be triggered. + Everies []string `pulumi:"everies"` + // ID of the schedule + ScheduleId *string `pulumi:"scheduleId"` + // ID of the stack for which to set up the scheduled task + StackId string `pulumi:"stackId"` + // Timezone in which the schedule is expressed. Defaults to `UTC`. + Timezone *string `pulumi:"timezone"` +} + +// The set of arguments for constructing a ScheduledTask resource. +type ScheduledTaskArgs struct { + // Timestamp (unix timestamp) at which time the scheduled task should happen. + At pulumi.IntPtrInput + // Command that will be run. + Command pulumi.StringInput + // List of cron schedule expressions based on which the scheduled task should be triggered. + Everies pulumi.StringArrayInput + // ID of the schedule + ScheduleId pulumi.StringPtrInput + // ID of the stack for which to set up the scheduled task + StackId pulumi.StringInput + // Timezone in which the schedule is expressed. Defaults to `UTC`. + Timezone pulumi.StringPtrInput +} + +func (ScheduledTaskArgs) ElementType() reflect.Type { + return reflect.TypeOf((*scheduledTaskArgs)(nil)).Elem() +} + +type ScheduledTaskInput interface { + pulumi.Input + + ToScheduledTaskOutput() ScheduledTaskOutput + ToScheduledTaskOutputWithContext(ctx context.Context) ScheduledTaskOutput +} + +func (*ScheduledTask) ElementType() reflect.Type { + return reflect.TypeOf((**ScheduledTask)(nil)).Elem() +} + +func (i *ScheduledTask) ToScheduledTaskOutput() ScheduledTaskOutput { + return i.ToScheduledTaskOutputWithContext(context.Background()) +} + +func (i *ScheduledTask) ToScheduledTaskOutputWithContext(ctx context.Context) ScheduledTaskOutput { + return pulumi.ToOutputWithContext(ctx, i).(ScheduledTaskOutput) +} + +func (i *ScheduledTask) ToOutput(ctx context.Context) pulumix.Output[*ScheduledTask] { + return pulumix.Output[*ScheduledTask]{ + OutputState: i.ToScheduledTaskOutputWithContext(ctx).OutputState, + } +} + +// ScheduledTaskArrayInput is an input type that accepts ScheduledTaskArray and ScheduledTaskArrayOutput values. +// You can construct a concrete instance of `ScheduledTaskArrayInput` via: +// +// ScheduledTaskArray{ ScheduledTaskArgs{...} } +type ScheduledTaskArrayInput interface { + pulumi.Input + + ToScheduledTaskArrayOutput() ScheduledTaskArrayOutput + ToScheduledTaskArrayOutputWithContext(context.Context) ScheduledTaskArrayOutput +} + +type ScheduledTaskArray []ScheduledTaskInput + +func (ScheduledTaskArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ScheduledTask)(nil)).Elem() +} + +func (i ScheduledTaskArray) ToScheduledTaskArrayOutput() ScheduledTaskArrayOutput { + return i.ToScheduledTaskArrayOutputWithContext(context.Background()) +} + +func (i ScheduledTaskArray) ToScheduledTaskArrayOutputWithContext(ctx context.Context) ScheduledTaskArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ScheduledTaskArrayOutput) +} + +func (i ScheduledTaskArray) ToOutput(ctx context.Context) pulumix.Output[[]*ScheduledTask] { + return pulumix.Output[[]*ScheduledTask]{ + OutputState: i.ToScheduledTaskArrayOutputWithContext(ctx).OutputState, + } +} + +// ScheduledTaskMapInput is an input type that accepts ScheduledTaskMap and ScheduledTaskMapOutput values. +// You can construct a concrete instance of `ScheduledTaskMapInput` via: +// +// ScheduledTaskMap{ "key": ScheduledTaskArgs{...} } +type ScheduledTaskMapInput interface { + pulumi.Input + + ToScheduledTaskMapOutput() ScheduledTaskMapOutput + ToScheduledTaskMapOutputWithContext(context.Context) ScheduledTaskMapOutput +} + +type ScheduledTaskMap map[string]ScheduledTaskInput + +func (ScheduledTaskMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ScheduledTask)(nil)).Elem() +} + +func (i ScheduledTaskMap) ToScheduledTaskMapOutput() ScheduledTaskMapOutput { + return i.ToScheduledTaskMapOutputWithContext(context.Background()) +} + +func (i ScheduledTaskMap) ToScheduledTaskMapOutputWithContext(ctx context.Context) ScheduledTaskMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ScheduledTaskMapOutput) +} + +func (i ScheduledTaskMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*ScheduledTask] { + return pulumix.Output[map[string]*ScheduledTask]{ + OutputState: i.ToScheduledTaskMapOutputWithContext(ctx).OutputState, + } +} + +type ScheduledTaskOutput struct{ *pulumi.OutputState } + +func (ScheduledTaskOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ScheduledTask)(nil)).Elem() +} + +func (o ScheduledTaskOutput) ToScheduledTaskOutput() ScheduledTaskOutput { + return o +} + +func (o ScheduledTaskOutput) ToScheduledTaskOutputWithContext(ctx context.Context) ScheduledTaskOutput { + return o +} + +func (o ScheduledTaskOutput) ToOutput(ctx context.Context) pulumix.Output[*ScheduledTask] { + return pulumix.Output[*ScheduledTask]{ + OutputState: o.OutputState, + } +} + +// Timestamp (unix timestamp) at which time the scheduled task should happen. +func (o ScheduledTaskOutput) At() pulumi.IntPtrOutput { + return o.ApplyT(func(v *ScheduledTask) pulumi.IntPtrOutput { return v.At }).(pulumi.IntPtrOutput) +} + +// Command that will be run. +func (o ScheduledTaskOutput) Command() pulumi.StringOutput { + return o.ApplyT(func(v *ScheduledTask) pulumi.StringOutput { return v.Command }).(pulumi.StringOutput) +} + +// List of cron schedule expressions based on which the scheduled task should be triggered. +func (o ScheduledTaskOutput) Everies() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ScheduledTask) pulumi.StringArrayOutput { return v.Everies }).(pulumi.StringArrayOutput) +} + +// ID of the schedule +func (o ScheduledTaskOutput) ScheduleId() pulumi.StringOutput { + return o.ApplyT(func(v *ScheduledTask) pulumi.StringOutput { return v.ScheduleId }).(pulumi.StringOutput) +} + +// ID of the stack for which to set up the scheduled task +func (o ScheduledTaskOutput) StackId() pulumi.StringOutput { + return o.ApplyT(func(v *ScheduledTask) pulumi.StringOutput { return v.StackId }).(pulumi.StringOutput) +} + +// Timezone in which the schedule is expressed. Defaults to `UTC`. +func (o ScheduledTaskOutput) Timezone() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ScheduledTask) pulumi.StringPtrOutput { return v.Timezone }).(pulumi.StringPtrOutput) +} + +type ScheduledTaskArrayOutput struct{ *pulumi.OutputState } + +func (ScheduledTaskArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ScheduledTask)(nil)).Elem() +} + +func (o ScheduledTaskArrayOutput) ToScheduledTaskArrayOutput() ScheduledTaskArrayOutput { + return o +} + +func (o ScheduledTaskArrayOutput) ToScheduledTaskArrayOutputWithContext(ctx context.Context) ScheduledTaskArrayOutput { + return o +} + +func (o ScheduledTaskArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*ScheduledTask] { + return pulumix.Output[[]*ScheduledTask]{ + OutputState: o.OutputState, + } +} + +func (o ScheduledTaskArrayOutput) Index(i pulumi.IntInput) ScheduledTaskOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ScheduledTask { + return vs[0].([]*ScheduledTask)[vs[1].(int)] + }).(ScheduledTaskOutput) +} + +type ScheduledTaskMapOutput struct{ *pulumi.OutputState } + +func (ScheduledTaskMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ScheduledTask)(nil)).Elem() +} + +func (o ScheduledTaskMapOutput) ToScheduledTaskMapOutput() ScheduledTaskMapOutput { + return o +} + +func (o ScheduledTaskMapOutput) ToScheduledTaskMapOutputWithContext(ctx context.Context) ScheduledTaskMapOutput { + return o +} + +func (o ScheduledTaskMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*ScheduledTask] { + return pulumix.Output[map[string]*ScheduledTask]{ + OutputState: o.OutputState, + } +} + +func (o ScheduledTaskMapOutput) MapIndex(k pulumi.StringInput) ScheduledTaskOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ScheduledTask { + return vs[0].(map[string]*ScheduledTask)[vs[1].(string)] + }).(ScheduledTaskOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ScheduledTaskInput)(nil)).Elem(), &ScheduledTask{}) + pulumi.RegisterInputType(reflect.TypeOf((*ScheduledTaskArrayInput)(nil)).Elem(), ScheduledTaskArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ScheduledTaskMapInput)(nil)).Elem(), ScheduledTaskMap{}) + pulumi.RegisterOutputType(ScheduledTaskOutput{}) + pulumi.RegisterOutputType(ScheduledTaskArrayOutput{}) + pulumi.RegisterOutputType(ScheduledTaskMapOutput{}) +} diff --git a/sdk/go/spacelift/space.go b/sdk/go/spacelift/space.go index 6ddd36d..053d7cb 100644 --- a/sdk/go/spacelift/space.go +++ b/sdk/go/spacelift/space.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Space` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. @@ -20,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -60,6 +62,8 @@ type Space struct { Description pulumi.StringPtrOutput `pulumi:"description"` // indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. InheritEntities pulumi.BoolPtrOutput `pulumi:"inheritEntities"` + // list of labels describing a space + Labels pulumi.StringArrayOutput `pulumi:"labels"` // name of the space Name pulumi.StringOutput `pulumi:"name"` // immutable ID (slug) of parent space. Defaults to `root`. @@ -73,7 +77,7 @@ func NewSpace(ctx *pulumi.Context, args = &SpaceArgs{} } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource Space err := ctx.RegisterResource("spacelift:index/space:Space", name, args, &resource, opts...) if err != nil { @@ -100,6 +104,8 @@ type spaceState struct { Description *string `pulumi:"description"` // indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. InheritEntities *bool `pulumi:"inheritEntities"` + // list of labels describing a space + Labels []string `pulumi:"labels"` // name of the space Name *string `pulumi:"name"` // immutable ID (slug) of parent space. Defaults to `root`. @@ -111,6 +117,8 @@ type SpaceState struct { Description pulumi.StringPtrInput // indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. InheritEntities pulumi.BoolPtrInput + // list of labels describing a space + Labels pulumi.StringArrayInput // name of the space Name pulumi.StringPtrInput // immutable ID (slug) of parent space. Defaults to `root`. @@ -126,6 +134,8 @@ type spaceArgs struct { Description *string `pulumi:"description"` // indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. InheritEntities *bool `pulumi:"inheritEntities"` + // list of labels describing a space + Labels []string `pulumi:"labels"` // name of the space Name *string `pulumi:"name"` // immutable ID (slug) of parent space. Defaults to `root`. @@ -138,6 +148,8 @@ type SpaceArgs struct { Description pulumi.StringPtrInput // indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. InheritEntities pulumi.BoolPtrInput + // list of labels describing a space + Labels pulumi.StringArrayInput // name of the space Name pulumi.StringPtrInput // immutable ID (slug) of parent space. Defaults to `root`. @@ -167,6 +179,12 @@ func (i *Space) ToSpaceOutputWithContext(ctx context.Context) SpaceOutput { return pulumi.ToOutputWithContext(ctx, i).(SpaceOutput) } +func (i *Space) ToOutput(ctx context.Context) pulumix.Output[*Space] { + return pulumix.Output[*Space]{ + OutputState: i.ToSpaceOutputWithContext(ctx).OutputState, + } +} + // SpaceArrayInput is an input type that accepts SpaceArray and SpaceArrayOutput values. // You can construct a concrete instance of `SpaceArrayInput` via: // @@ -192,6 +210,12 @@ func (i SpaceArray) ToSpaceArrayOutputWithContext(ctx context.Context) SpaceArra return pulumi.ToOutputWithContext(ctx, i).(SpaceArrayOutput) } +func (i SpaceArray) ToOutput(ctx context.Context) pulumix.Output[[]*Space] { + return pulumix.Output[[]*Space]{ + OutputState: i.ToSpaceArrayOutputWithContext(ctx).OutputState, + } +} + // SpaceMapInput is an input type that accepts SpaceMap and SpaceMapOutput values. // You can construct a concrete instance of `SpaceMapInput` via: // @@ -217,6 +241,12 @@ func (i SpaceMap) ToSpaceMapOutputWithContext(ctx context.Context) SpaceMapOutpu return pulumi.ToOutputWithContext(ctx, i).(SpaceMapOutput) } +func (i SpaceMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Space] { + return pulumix.Output[map[string]*Space]{ + OutputState: i.ToSpaceMapOutputWithContext(ctx).OutputState, + } +} + type SpaceOutput struct{ *pulumi.OutputState } func (SpaceOutput) ElementType() reflect.Type { @@ -231,6 +261,12 @@ func (o SpaceOutput) ToSpaceOutputWithContext(ctx context.Context) SpaceOutput { return o } +func (o SpaceOutput) ToOutput(ctx context.Context) pulumix.Output[*Space] { + return pulumix.Output[*Space]{ + OutputState: o.OutputState, + } +} + // free-form space description for users func (o SpaceOutput) Description() pulumi.StringPtrOutput { return o.ApplyT(func(v *Space) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) @@ -241,6 +277,11 @@ func (o SpaceOutput) InheritEntities() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Space) pulumi.BoolPtrOutput { return v.InheritEntities }).(pulumi.BoolPtrOutput) } +// list of labels describing a space +func (o SpaceOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Space) pulumi.StringArrayOutput { return v.Labels }).(pulumi.StringArrayOutput) +} + // name of the space func (o SpaceOutput) Name() pulumi.StringOutput { return o.ApplyT(func(v *Space) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) @@ -265,6 +306,12 @@ func (o SpaceArrayOutput) ToSpaceArrayOutputWithContext(ctx context.Context) Spa return o } +func (o SpaceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Space] { + return pulumix.Output[[]*Space]{ + OutputState: o.OutputState, + } +} + func (o SpaceArrayOutput) Index(i pulumi.IntInput) SpaceOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Space { return vs[0].([]*Space)[vs[1].(int)] @@ -285,6 +332,12 @@ func (o SpaceMapOutput) ToSpaceMapOutputWithContext(ctx context.Context) SpaceMa return o } +func (o SpaceMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Space] { + return pulumix.Output[map[string]*Space]{ + OutputState: o.OutputState, + } +} + func (o SpaceMapOutput) MapIndex(k pulumi.StringInput) SpaceOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Space { return vs[0].(map[string]*Space)[vs[1].(string)] diff --git a/sdk/go/spacelift/stack.go b/sdk/go/spacelift/stack.go index 41de2e6..b638a2a 100644 --- a/sdk/go/spacelift/stack.go +++ b/sdk/go/spacelift/stack.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Stack` combines source code and configuration to create a runtime environment where resources are managed. In this way it's similar to a stack in AWS CloudFormation, or a project on generic CI/CD platforms. @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -30,14 +32,14 @@ import ( // _, err := spacelift.NewStack(ctx, "k8s-cluster-bitbucket-cloud", &spacelift.StackArgs{ // Administrative: pulumi.Bool(true), // Autodeploy: pulumi.Bool(true), -// BitbucketCloud: &StackBitbucketCloudArgs{ +// BitbucketCloud: &spacelift.StackBitbucketCloudArgs{ // Namespace: pulumi.String("SPACELIFT"), // }, // Branch: pulumi.String("master"), // Description: pulumi.String("Provisions a Kubernetes cluster"), // ProjectRoot: pulumi.String("cluster"), // Repository: pulumi.String("core-infra"), -// TerraformVersion: pulumi.String("0.12.6"), +// TerraformVersion: pulumi.String("1.3.0"), // }) // if err != nil { // return err @@ -45,14 +47,14 @@ import ( // _, err = spacelift.NewStack(ctx, "k8s-cluster-bitbucket-datacenter", &spacelift.StackArgs{ // Administrative: pulumi.Bool(true), // Autodeploy: pulumi.Bool(true), -// BitbucketDatacenter: &StackBitbucketDatacenterArgs{ +// BitbucketDatacenter: &spacelift.StackBitbucketDatacenterArgs{ // Namespace: pulumi.String("SPACELIFT"), // }, // Branch: pulumi.String("master"), // Description: pulumi.String("Provisions a Kubernetes cluster"), // ProjectRoot: pulumi.String("cluster"), // Repository: pulumi.String("core-infra"), -// TerraformVersion: pulumi.String("0.12.6"), +// TerraformVersion: pulumi.String("1.3.0"), // }) // if err != nil { // return err @@ -62,12 +64,12 @@ import ( // Autodeploy: pulumi.Bool(true), // Branch: pulumi.String("master"), // Description: pulumi.String("Provisions a Kubernetes cluster"), -// GithubEnterprise: &StackGithubEnterpriseArgs{ +// GithubEnterprise: &spacelift.StackGithubEnterpriseArgs{ // Namespace: pulumi.String("spacelift"), // }, // ProjectRoot: pulumi.String("cluster"), // Repository: pulumi.String("core-infra"), -// TerraformVersion: pulumi.String("0.12.6"), +// TerraformVersion: pulumi.String("1.3.0"), // }) // if err != nil { // return err @@ -77,25 +79,25 @@ import ( // Autodeploy: pulumi.Bool(true), // Branch: pulumi.String("master"), // Description: pulumi.String("Provisions a Kubernetes cluster"), -// Gitlab: &StackGitlabArgs{ +// Gitlab: &spacelift.StackGitlabArgs{ // Namespace: pulumi.String("spacelift"), // }, // ProjectRoot: pulumi.String("cluster"), // Repository: pulumi.String("core-infra"), -// TerraformVersion: pulumi.String("0.12.6"), +// TerraformVersion: pulumi.String("1.3.0"), // }) // if err != nil { // return err // } // _, err = spacelift.NewStack(ctx, "k8s-cluster", &spacelift.StackArgs{ -// Administrative: pulumi.Bool(true), -// Autodeploy: pulumi.Bool(true), -// Branch: pulumi.String("master"), -// Description: pulumi.String("Provisions a Kubernetes cluster"), -// ProjectRoot: pulumi.String("cluster"), -// Repository: pulumi.String("core-infra"), -// TerraformSmartSanitization: pulumi.Bool(true), -// TerraformVersion: pulumi.String("1.2.6"), +// Administrative: pulumi.Bool(true), +// Autodeploy: pulumi.Bool(true), +// Branch: pulumi.String("master"), +// Description: pulumi.String("Provisions a Kubernetes cluster"), +// ProjectRoot: pulumi.String("cluster"), +// Repository: pulumi.String("core-infra"), +// TerraformExternalStateAccess: pulumi.Bool(true), +// TerraformVersion: pulumi.String("1.3.0"), // }) // if err != nil { // return err @@ -103,7 +105,7 @@ import ( // _, err = spacelift.NewStack(ctx, "k8s-cluster-cloudformation", &spacelift.StackArgs{ // Autodeploy: pulumi.Bool(true), // Branch: pulumi.String("master"), -// Cloudformation: &StackCloudformationArgs{ +// Cloudformation: &spacelift.StackCloudformationArgs{ // EntryTemplateFile: pulumi.String("main.yaml"), // Region: pulumi.String("eu-central-1"), // StackName: pulumi.String("k8s-cluster"), @@ -121,7 +123,7 @@ import ( // Branch: pulumi.String("master"), // Description: pulumi.String("Provisions a Kubernetes cluster"), // ProjectRoot: pulumi.String("cluster"), -// Pulumi: &StackPulumiArgs{ +// Pulumi: &spacelift.StackPulumiArgs{ // LoginUrl: pulumi.String("s3://pulumi-state-bucket"), // StackName: pulumi.String("kubernetes-core-services"), // }, @@ -138,8 +140,9 @@ import ( // }, // Branch: pulumi.String("master"), // Description: pulumi.String("Shared cluster services (Datadog, Istio etc.)"), -// Kubernetes: &StackKubernetesArgs{ -// Namespace: pulumi.String("core"), +// Kubernetes: &spacelift.StackKubernetesArgs{ +// KubectlVersion: pulumi.String("1.26.1"), +// Namespace: pulumi.String("core"), // }, // ProjectRoot: pulumi.String("core-services"), // Repository: pulumi.String("core-infra"), @@ -148,7 +151,7 @@ import ( // return err // } // _, err = spacelift.NewStack(ctx, "ansible-stack", &spacelift.StackArgs{ -// Ansible: &StackAnsibleArgs{ +// Ansible: &spacelift.StackAnsibleArgs{ // Playbook: pulumi.String("main.yml"), // }, // Autodeploy: pulumi.Bool(true), @@ -188,6 +191,8 @@ type Stack struct { AfterPerforms pulumi.StringArrayOutput `pulumi:"afterPerforms"` // List of after-plan scripts AfterPlans pulumi.StringArrayOutput `pulumi:"afterPlans"` + // List of after-run scripts + AfterRuns pulumi.StringArrayOutput `pulumi:"afterRuns"` // Ansible-specific configuration. Presence means this Stack is an Ansible Stack. Ansible StackAnsiblePtrOutput `pulumi:"ansible"` // Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. @@ -220,9 +225,9 @@ type Stack struct { Description pulumi.StringPtrOutput `pulumi:"description"` // Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. EnableLocalPreview pulumi.BoolPtrOutput `pulumi:"enableLocalPreview"` - // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. GithubActionDeploy pulumi.BoolPtrOutput `pulumi:"githubActionDeploy"` - // GitHub Enterprise (self-hosted) VCS settings + // VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) GithubEnterprise StackGithubEnterprisePtrOutput `pulumi:"githubEnterprise"` // GitLab VCS settings Gitlab StackGitlabPtrOutput `pulumi:"gitlab"` @@ -243,6 +248,8 @@ type Stack struct { ProtectFromDeletion pulumi.BoolPtrOutput `pulumi:"protectFromDeletion"` // Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. Pulumi StackPulumiPtrOutput `pulumi:"pulumi"` + // One-way VCS integration using a raw Git repository link + RawGit StackRawGitPtrOutput `pulumi:"rawGit"` // Name of the repository, without the owner part Repository pulumi.StringOutput `pulumi:"repository"` // Name of the Docker image used to process Runs @@ -250,17 +257,23 @@ type Stack struct { Showcase StackShowcasePtrOutput `pulumi:"showcase"` // Allows setting the custom ID (slug) for the stack Slug pulumi.StringOutput `pulumi:"slug"` - // ID (slug) of the space the stack is in + // ID (slug) of the space the stack is in. Defaults to `legacy`. SpaceId pulumi.StringOutput `pulumi:"spaceId"` + // Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + TerraformExternalStateAccess pulumi.BoolPtrOutput `pulumi:"terraformExternalStateAccess"` // Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state // and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. // Defaults to `false`. TerraformSmartSanitization pulumi.BoolPtrOutput `pulumi:"terraformSmartSanitization"` // Terraform version to use TerraformVersion pulumi.StringPtrOutput `pulumi:"terraformVersion"` + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + TerraformWorkflowTool pulumi.StringOutput `pulumi:"terraformWorkflowTool"` // Terraform workspace to select TerraformWorkspace pulumi.StringPtrOutput `pulumi:"terraformWorkspace"` - // ID of the worker pool to use + // Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + Terragrunt StackTerragruntPtrOutput `pulumi:"terragrunt"` + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId pulumi.StringPtrOutput `pulumi:"workerPoolId"` } @@ -277,7 +290,14 @@ func NewStack(ctx *pulumi.Context, if args.Repository == nil { return nil, errors.New("invalid value for required argument 'Repository'") } - opts = pkgResourceDefaultOpts(opts) + if args.ImportState != nil { + args.ImportState = pulumi.ToSecret(args.ImportState).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "importState", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) var resource Stack err := ctx.RegisterResource("spacelift:index/stack:Stack", name, args, &resource, opts...) if err != nil { @@ -312,6 +332,8 @@ type stackState struct { AfterPerforms []string `pulumi:"afterPerforms"` // List of after-plan scripts AfterPlans []string `pulumi:"afterPlans"` + // List of after-run scripts + AfterRuns []string `pulumi:"afterRuns"` // Ansible-specific configuration. Presence means this Stack is an Ansible Stack. Ansible *StackAnsible `pulumi:"ansible"` // Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. @@ -344,9 +366,9 @@ type stackState struct { Description *string `pulumi:"description"` // Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. EnableLocalPreview *bool `pulumi:"enableLocalPreview"` - // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. GithubActionDeploy *bool `pulumi:"githubActionDeploy"` - // GitHub Enterprise (self-hosted) VCS settings + // VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) GithubEnterprise *StackGithubEnterprise `pulumi:"githubEnterprise"` // GitLab VCS settings Gitlab *StackGitlab `pulumi:"gitlab"` @@ -367,6 +389,8 @@ type stackState struct { ProtectFromDeletion *bool `pulumi:"protectFromDeletion"` // Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. Pulumi *StackPulumi `pulumi:"pulumi"` + // One-way VCS integration using a raw Git repository link + RawGit *StackRawGit `pulumi:"rawGit"` // Name of the repository, without the owner part Repository *string `pulumi:"repository"` // Name of the Docker image used to process Runs @@ -374,17 +398,23 @@ type stackState struct { Showcase *StackShowcase `pulumi:"showcase"` // Allows setting the custom ID (slug) for the stack Slug *string `pulumi:"slug"` - // ID (slug) of the space the stack is in + // ID (slug) of the space the stack is in. Defaults to `legacy`. SpaceId *string `pulumi:"spaceId"` + // Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + TerraformExternalStateAccess *bool `pulumi:"terraformExternalStateAccess"` // Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state // and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. // Defaults to `false`. TerraformSmartSanitization *bool `pulumi:"terraformSmartSanitization"` // Terraform version to use TerraformVersion *string `pulumi:"terraformVersion"` + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + TerraformWorkflowTool *string `pulumi:"terraformWorkflowTool"` // Terraform workspace to select TerraformWorkspace *string `pulumi:"terraformWorkspace"` - // ID of the worker pool to use + // Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + Terragrunt *StackTerragrunt `pulumi:"terragrunt"` + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId *string `pulumi:"workerPoolId"` } @@ -401,6 +431,8 @@ type StackState struct { AfterPerforms pulumi.StringArrayInput // List of after-plan scripts AfterPlans pulumi.StringArrayInput + // List of after-run scripts + AfterRuns pulumi.StringArrayInput // Ansible-specific configuration. Presence means this Stack is an Ansible Stack. Ansible StackAnsiblePtrInput // Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. @@ -433,9 +465,9 @@ type StackState struct { Description pulumi.StringPtrInput // Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. EnableLocalPreview pulumi.BoolPtrInput - // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. GithubActionDeploy pulumi.BoolPtrInput - // GitHub Enterprise (self-hosted) VCS settings + // VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) GithubEnterprise StackGithubEnterprisePtrInput // GitLab VCS settings Gitlab StackGitlabPtrInput @@ -456,6 +488,8 @@ type StackState struct { ProtectFromDeletion pulumi.BoolPtrInput // Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. Pulumi StackPulumiPtrInput + // One-way VCS integration using a raw Git repository link + RawGit StackRawGitPtrInput // Name of the repository, without the owner part Repository pulumi.StringPtrInput // Name of the Docker image used to process Runs @@ -463,17 +497,23 @@ type StackState struct { Showcase StackShowcasePtrInput // Allows setting the custom ID (slug) for the stack Slug pulumi.StringPtrInput - // ID (slug) of the space the stack is in + // ID (slug) of the space the stack is in. Defaults to `legacy`. SpaceId pulumi.StringPtrInput + // Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + TerraformExternalStateAccess pulumi.BoolPtrInput // Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state // and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. // Defaults to `false`. TerraformSmartSanitization pulumi.BoolPtrInput // Terraform version to use TerraformVersion pulumi.StringPtrInput + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + TerraformWorkflowTool pulumi.StringPtrInput // Terraform workspace to select TerraformWorkspace pulumi.StringPtrInput - // ID of the worker pool to use + // Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + Terragrunt StackTerragruntPtrInput + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId pulumi.StringPtrInput } @@ -494,6 +534,8 @@ type stackArgs struct { AfterPerforms []string `pulumi:"afterPerforms"` // List of after-plan scripts AfterPlans []string `pulumi:"afterPlans"` + // List of after-run scripts + AfterRuns []string `pulumi:"afterRuns"` // Ansible-specific configuration. Presence means this Stack is an Ansible Stack. Ansible *StackAnsible `pulumi:"ansible"` // Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. @@ -524,9 +566,9 @@ type stackArgs struct { Description *string `pulumi:"description"` // Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. EnableLocalPreview *bool `pulumi:"enableLocalPreview"` - // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. GithubActionDeploy *bool `pulumi:"githubActionDeploy"` - // GitHub Enterprise (self-hosted) VCS settings + // VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) GithubEnterprise *StackGithubEnterprise `pulumi:"githubEnterprise"` // GitLab VCS settings Gitlab *StackGitlab `pulumi:"gitlab"` @@ -547,6 +589,8 @@ type stackArgs struct { ProtectFromDeletion *bool `pulumi:"protectFromDeletion"` // Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. Pulumi *StackPulumi `pulumi:"pulumi"` + // One-way VCS integration using a raw Git repository link + RawGit *StackRawGit `pulumi:"rawGit"` // Name of the repository, without the owner part Repository string `pulumi:"repository"` // Name of the Docker image used to process Runs @@ -554,17 +598,23 @@ type stackArgs struct { Showcase *StackShowcase `pulumi:"showcase"` // Allows setting the custom ID (slug) for the stack Slug *string `pulumi:"slug"` - // ID (slug) of the space the stack is in + // ID (slug) of the space the stack is in. Defaults to `legacy`. SpaceId *string `pulumi:"spaceId"` + // Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + TerraformExternalStateAccess *bool `pulumi:"terraformExternalStateAccess"` // Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state // and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. // Defaults to `false`. TerraformSmartSanitization *bool `pulumi:"terraformSmartSanitization"` // Terraform version to use TerraformVersion *string `pulumi:"terraformVersion"` + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + TerraformWorkflowTool *string `pulumi:"terraformWorkflowTool"` // Terraform workspace to select TerraformWorkspace *string `pulumi:"terraformWorkspace"` - // ID of the worker pool to use + // Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + Terragrunt *StackTerragrunt `pulumi:"terragrunt"` + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId *string `pulumi:"workerPoolId"` } @@ -582,6 +632,8 @@ type StackArgs struct { AfterPerforms pulumi.StringArrayInput // List of after-plan scripts AfterPlans pulumi.StringArrayInput + // List of after-run scripts + AfterRuns pulumi.StringArrayInput // Ansible-specific configuration. Presence means this Stack is an Ansible Stack. Ansible StackAnsiblePtrInput // Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. @@ -612,9 +664,9 @@ type StackArgs struct { Description pulumi.StringPtrInput // Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. EnableLocalPreview pulumi.BoolPtrInput - // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + // Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. GithubActionDeploy pulumi.BoolPtrInput - // GitHub Enterprise (self-hosted) VCS settings + // VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) GithubEnterprise StackGithubEnterprisePtrInput // GitLab VCS settings Gitlab StackGitlabPtrInput @@ -635,6 +687,8 @@ type StackArgs struct { ProtectFromDeletion pulumi.BoolPtrInput // Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. Pulumi StackPulumiPtrInput + // One-way VCS integration using a raw Git repository link + RawGit StackRawGitPtrInput // Name of the repository, without the owner part Repository pulumi.StringInput // Name of the Docker image used to process Runs @@ -642,17 +696,23 @@ type StackArgs struct { Showcase StackShowcasePtrInput // Allows setting the custom ID (slug) for the stack Slug pulumi.StringPtrInput - // ID (slug) of the space the stack is in + // ID (slug) of the space the stack is in. Defaults to `legacy`. SpaceId pulumi.StringPtrInput + // Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + TerraformExternalStateAccess pulumi.BoolPtrInput // Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state // and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. // Defaults to `false`. TerraformSmartSanitization pulumi.BoolPtrInput // Terraform version to use TerraformVersion pulumi.StringPtrInput + // Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + TerraformWorkflowTool pulumi.StringPtrInput // Terraform workspace to select TerraformWorkspace pulumi.StringPtrInput - // ID of the worker pool to use + // Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + Terragrunt StackTerragruntPtrInput + // ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. WorkerPoolId pulumi.StringPtrInput } @@ -679,6 +739,12 @@ func (i *Stack) ToStackOutputWithContext(ctx context.Context) StackOutput { return pulumi.ToOutputWithContext(ctx, i).(StackOutput) } +func (i *Stack) ToOutput(ctx context.Context) pulumix.Output[*Stack] { + return pulumix.Output[*Stack]{ + OutputState: i.ToStackOutputWithContext(ctx).OutputState, + } +} + // StackArrayInput is an input type that accepts StackArray and StackArrayOutput values. // You can construct a concrete instance of `StackArrayInput` via: // @@ -704,6 +770,12 @@ func (i StackArray) ToStackArrayOutputWithContext(ctx context.Context) StackArra return pulumi.ToOutputWithContext(ctx, i).(StackArrayOutput) } +func (i StackArray) ToOutput(ctx context.Context) pulumix.Output[[]*Stack] { + return pulumix.Output[[]*Stack]{ + OutputState: i.ToStackArrayOutputWithContext(ctx).OutputState, + } +} + // StackMapInput is an input type that accepts StackMap and StackMapOutput values. // You can construct a concrete instance of `StackMapInput` via: // @@ -729,6 +801,12 @@ func (i StackMap) ToStackMapOutputWithContext(ctx context.Context) StackMapOutpu return pulumi.ToOutputWithContext(ctx, i).(StackMapOutput) } +func (i StackMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Stack] { + return pulumix.Output[map[string]*Stack]{ + OutputState: i.ToStackMapOutputWithContext(ctx).OutputState, + } +} + type StackOutput struct{ *pulumi.OutputState } func (StackOutput) ElementType() reflect.Type { @@ -743,6 +821,12 @@ func (o StackOutput) ToStackOutputWithContext(ctx context.Context) StackOutput { return o } +func (o StackOutput) ToOutput(ctx context.Context) pulumix.Output[*Stack] { + return pulumix.Output[*Stack]{ + OutputState: o.OutputState, + } +} + // Indicates whether this stack can manage others. Defaults to `false`. func (o StackOutput) Administrative() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Stack) pulumi.BoolPtrOutput { return v.Administrative }).(pulumi.BoolPtrOutput) @@ -773,6 +857,11 @@ func (o StackOutput) AfterPlans() pulumi.StringArrayOutput { return o.ApplyT(func(v *Stack) pulumi.StringArrayOutput { return v.AfterPlans }).(pulumi.StringArrayOutput) } +// List of after-run scripts +func (o StackOutput) AfterRuns() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Stack) pulumi.StringArrayOutput { return v.AfterRuns }).(pulumi.StringArrayOutput) +} + // Ansible-specific configuration. Presence means this Stack is an Ansible Stack. func (o StackOutput) Ansible() StackAnsiblePtrOutput { return o.ApplyT(func(v *Stack) StackAnsiblePtrOutput { return v.Ansible }).(StackAnsiblePtrOutput) @@ -853,12 +942,12 @@ func (o StackOutput) EnableLocalPreview() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Stack) pulumi.BoolPtrOutput { return v.EnableLocalPreview }).(pulumi.BoolPtrOutput) } -// Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. +// Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. func (o StackOutput) GithubActionDeploy() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Stack) pulumi.BoolPtrOutput { return v.GithubActionDeploy }).(pulumi.BoolPtrOutput) } -// GitHub Enterprise (self-hosted) VCS settings +// VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) func (o StackOutput) GithubEnterprise() StackGithubEnterprisePtrOutput { return o.ApplyT(func(v *Stack) StackGithubEnterprisePtrOutput { return v.GithubEnterprise }).(StackGithubEnterprisePtrOutput) } @@ -912,6 +1001,11 @@ func (o StackOutput) Pulumi() StackPulumiPtrOutput { return o.ApplyT(func(v *Stack) StackPulumiPtrOutput { return v.Pulumi }).(StackPulumiPtrOutput) } +// One-way VCS integration using a raw Git repository link +func (o StackOutput) RawGit() StackRawGitPtrOutput { + return o.ApplyT(func(v *Stack) StackRawGitPtrOutput { return v.RawGit }).(StackRawGitPtrOutput) +} + // Name of the repository, without the owner part func (o StackOutput) Repository() pulumi.StringOutput { return o.ApplyT(func(v *Stack) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) @@ -931,11 +1025,16 @@ func (o StackOutput) Slug() pulumi.StringOutput { return o.ApplyT(func(v *Stack) pulumi.StringOutput { return v.Slug }).(pulumi.StringOutput) } -// ID (slug) of the space the stack is in +// ID (slug) of the space the stack is in. Defaults to `legacy`. func (o StackOutput) SpaceId() pulumi.StringOutput { return o.ApplyT(func(v *Stack) pulumi.StringOutput { return v.SpaceId }).(pulumi.StringOutput) } +// Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. +func (o StackOutput) TerraformExternalStateAccess() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Stack) pulumi.BoolPtrOutput { return v.TerraformExternalStateAccess }).(pulumi.BoolPtrOutput) +} + // Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state // and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. // Defaults to `false`. @@ -948,12 +1047,22 @@ func (o StackOutput) TerraformVersion() pulumi.StringPtrOutput { return o.ApplyT(func(v *Stack) pulumi.StringPtrOutput { return v.TerraformVersion }).(pulumi.StringPtrOutput) } +// Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. +func (o StackOutput) TerraformWorkflowTool() pulumi.StringOutput { + return o.ApplyT(func(v *Stack) pulumi.StringOutput { return v.TerraformWorkflowTool }).(pulumi.StringOutput) +} + // Terraform workspace to select func (o StackOutput) TerraformWorkspace() pulumi.StringPtrOutput { return o.ApplyT(func(v *Stack) pulumi.StringPtrOutput { return v.TerraformWorkspace }).(pulumi.StringPtrOutput) } -// ID of the worker pool to use +// Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. +func (o StackOutput) Terragrunt() StackTerragruntPtrOutput { + return o.ApplyT(func(v *Stack) StackTerragruntPtrOutput { return v.Terragrunt }).(StackTerragruntPtrOutput) +} + +// ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. func (o StackOutput) WorkerPoolId() pulumi.StringPtrOutput { return o.ApplyT(func(v *Stack) pulumi.StringPtrOutput { return v.WorkerPoolId }).(pulumi.StringPtrOutput) } @@ -972,6 +1081,12 @@ func (o StackArrayOutput) ToStackArrayOutputWithContext(ctx context.Context) Sta return o } +func (o StackArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Stack] { + return pulumix.Output[[]*Stack]{ + OutputState: o.OutputState, + } +} + func (o StackArrayOutput) Index(i pulumi.IntInput) StackOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Stack { return vs[0].([]*Stack)[vs[1].(int)] @@ -992,6 +1107,12 @@ func (o StackMapOutput) ToStackMapOutputWithContext(ctx context.Context) StackMa return o } +func (o StackMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Stack] { + return pulumix.Output[map[string]*Stack]{ + OutputState: o.OutputState, + } +} + func (o StackMapOutput) MapIndex(k pulumi.StringInput) StackOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Stack { return vs[0].(map[string]*Stack)[vs[1].(string)] diff --git a/sdk/go/spacelift/stackActivator.go b/sdk/go/spacelift/stackActivator.go new file mode 100644 index 0000000..afa49f1 --- /dev/null +++ b/sdk/go/spacelift/stackActivator.go @@ -0,0 +1,308 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `StackActivator` is used to to enable/disable Spacelift Stack. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// app, err := spacelift.NewStack(ctx, "app", &spacelift.StackArgs{ +// Branch: pulumi.String("master"), +// Repository: pulumi.String("app"), +// }) +// if err != nil { +// return err +// } +// _, err = spacelift.NewStackActivator(ctx, "test", &spacelift.StackActivatorArgs{ +// Enabled: pulumi.Bool(true), +// StackId: app.ID(), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type StackActivator struct { + pulumi.CustomResourceState + + // Enable/disable stack + Enabled pulumi.BoolOutput `pulumi:"enabled"` + // ID of the stack to enable/disable + StackId pulumi.StringOutput `pulumi:"stackId"` +} + +// NewStackActivator registers a new resource with the given unique name, arguments, and options. +func NewStackActivator(ctx *pulumi.Context, + name string, args *StackActivatorArgs, opts ...pulumi.ResourceOption) (*StackActivator, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Enabled == nil { + return nil, errors.New("invalid value for required argument 'Enabled'") + } + if args.StackId == nil { + return nil, errors.New("invalid value for required argument 'StackId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource StackActivator + err := ctx.RegisterResource("spacelift:index/stackActivator:StackActivator", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetStackActivator gets an existing StackActivator resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetStackActivator(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *StackActivatorState, opts ...pulumi.ResourceOption) (*StackActivator, error) { + var resource StackActivator + err := ctx.ReadResource("spacelift:index/stackActivator:StackActivator", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering StackActivator resources. +type stackActivatorState struct { + // Enable/disable stack + Enabled *bool `pulumi:"enabled"` + // ID of the stack to enable/disable + StackId *string `pulumi:"stackId"` +} + +type StackActivatorState struct { + // Enable/disable stack + Enabled pulumi.BoolPtrInput + // ID of the stack to enable/disable + StackId pulumi.StringPtrInput +} + +func (StackActivatorState) ElementType() reflect.Type { + return reflect.TypeOf((*stackActivatorState)(nil)).Elem() +} + +type stackActivatorArgs struct { + // Enable/disable stack + Enabled bool `pulumi:"enabled"` + // ID of the stack to enable/disable + StackId string `pulumi:"stackId"` +} + +// The set of arguments for constructing a StackActivator resource. +type StackActivatorArgs struct { + // Enable/disable stack + Enabled pulumi.BoolInput + // ID of the stack to enable/disable + StackId pulumi.StringInput +} + +func (StackActivatorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*stackActivatorArgs)(nil)).Elem() +} + +type StackActivatorInput interface { + pulumi.Input + + ToStackActivatorOutput() StackActivatorOutput + ToStackActivatorOutputWithContext(ctx context.Context) StackActivatorOutput +} + +func (*StackActivator) ElementType() reflect.Type { + return reflect.TypeOf((**StackActivator)(nil)).Elem() +} + +func (i *StackActivator) ToStackActivatorOutput() StackActivatorOutput { + return i.ToStackActivatorOutputWithContext(context.Background()) +} + +func (i *StackActivator) ToStackActivatorOutputWithContext(ctx context.Context) StackActivatorOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackActivatorOutput) +} + +func (i *StackActivator) ToOutput(ctx context.Context) pulumix.Output[*StackActivator] { + return pulumix.Output[*StackActivator]{ + OutputState: i.ToStackActivatorOutputWithContext(ctx).OutputState, + } +} + +// StackActivatorArrayInput is an input type that accepts StackActivatorArray and StackActivatorArrayOutput values. +// You can construct a concrete instance of `StackActivatorArrayInput` via: +// +// StackActivatorArray{ StackActivatorArgs{...} } +type StackActivatorArrayInput interface { + pulumi.Input + + ToStackActivatorArrayOutput() StackActivatorArrayOutput + ToStackActivatorArrayOutputWithContext(context.Context) StackActivatorArrayOutput +} + +type StackActivatorArray []StackActivatorInput + +func (StackActivatorArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*StackActivator)(nil)).Elem() +} + +func (i StackActivatorArray) ToStackActivatorArrayOutput() StackActivatorArrayOutput { + return i.ToStackActivatorArrayOutputWithContext(context.Background()) +} + +func (i StackActivatorArray) ToStackActivatorArrayOutputWithContext(ctx context.Context) StackActivatorArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackActivatorArrayOutput) +} + +func (i StackActivatorArray) ToOutput(ctx context.Context) pulumix.Output[[]*StackActivator] { + return pulumix.Output[[]*StackActivator]{ + OutputState: i.ToStackActivatorArrayOutputWithContext(ctx).OutputState, + } +} + +// StackActivatorMapInput is an input type that accepts StackActivatorMap and StackActivatorMapOutput values. +// You can construct a concrete instance of `StackActivatorMapInput` via: +// +// StackActivatorMap{ "key": StackActivatorArgs{...} } +type StackActivatorMapInput interface { + pulumi.Input + + ToStackActivatorMapOutput() StackActivatorMapOutput + ToStackActivatorMapOutputWithContext(context.Context) StackActivatorMapOutput +} + +type StackActivatorMap map[string]StackActivatorInput + +func (StackActivatorMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*StackActivator)(nil)).Elem() +} + +func (i StackActivatorMap) ToStackActivatorMapOutput() StackActivatorMapOutput { + return i.ToStackActivatorMapOutputWithContext(context.Background()) +} + +func (i StackActivatorMap) ToStackActivatorMapOutputWithContext(ctx context.Context) StackActivatorMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackActivatorMapOutput) +} + +func (i StackActivatorMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackActivator] { + return pulumix.Output[map[string]*StackActivator]{ + OutputState: i.ToStackActivatorMapOutputWithContext(ctx).OutputState, + } +} + +type StackActivatorOutput struct{ *pulumi.OutputState } + +func (StackActivatorOutput) ElementType() reflect.Type { + return reflect.TypeOf((**StackActivator)(nil)).Elem() +} + +func (o StackActivatorOutput) ToStackActivatorOutput() StackActivatorOutput { + return o +} + +func (o StackActivatorOutput) ToStackActivatorOutputWithContext(ctx context.Context) StackActivatorOutput { + return o +} + +func (o StackActivatorOutput) ToOutput(ctx context.Context) pulumix.Output[*StackActivator] { + return pulumix.Output[*StackActivator]{ + OutputState: o.OutputState, + } +} + +// Enable/disable stack +func (o StackActivatorOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v *StackActivator) pulumi.BoolOutput { return v.Enabled }).(pulumi.BoolOutput) +} + +// ID of the stack to enable/disable +func (o StackActivatorOutput) StackId() pulumi.StringOutput { + return o.ApplyT(func(v *StackActivator) pulumi.StringOutput { return v.StackId }).(pulumi.StringOutput) +} + +type StackActivatorArrayOutput struct{ *pulumi.OutputState } + +func (StackActivatorArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*StackActivator)(nil)).Elem() +} + +func (o StackActivatorArrayOutput) ToStackActivatorArrayOutput() StackActivatorArrayOutput { + return o +} + +func (o StackActivatorArrayOutput) ToStackActivatorArrayOutputWithContext(ctx context.Context) StackActivatorArrayOutput { + return o +} + +func (o StackActivatorArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StackActivator] { + return pulumix.Output[[]*StackActivator]{ + OutputState: o.OutputState, + } +} + +func (o StackActivatorArrayOutput) Index(i pulumi.IntInput) StackActivatorOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StackActivator { + return vs[0].([]*StackActivator)[vs[1].(int)] + }).(StackActivatorOutput) +} + +type StackActivatorMapOutput struct{ *pulumi.OutputState } + +func (StackActivatorMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*StackActivator)(nil)).Elem() +} + +func (o StackActivatorMapOutput) ToStackActivatorMapOutput() StackActivatorMapOutput { + return o +} + +func (o StackActivatorMapOutput) ToStackActivatorMapOutputWithContext(ctx context.Context) StackActivatorMapOutput { + return o +} + +func (o StackActivatorMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackActivator] { + return pulumix.Output[map[string]*StackActivator]{ + OutputState: o.OutputState, + } +} + +func (o StackActivatorMapOutput) MapIndex(k pulumi.StringInput) StackActivatorOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StackActivator { + return vs[0].(map[string]*StackActivator)[vs[1].(string)] + }).(StackActivatorOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*StackActivatorInput)(nil)).Elem(), &StackActivator{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackActivatorArrayInput)(nil)).Elem(), StackActivatorArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackActivatorMapInput)(nil)).Elem(), StackActivatorMap{}) + pulumi.RegisterOutputType(StackActivatorOutput{}) + pulumi.RegisterOutputType(StackActivatorArrayOutput{}) + pulumi.RegisterOutputType(StackActivatorMapOutput{}) +} diff --git a/sdk/go/spacelift/stackAwsRole.go b/sdk/go/spacelift/stackAwsRole.go index 1b64e96..34eff42 100644 --- a/sdk/go/spacelift/stackAwsRole.go +++ b/sdk/go/spacelift/stackAwsRole.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // > **Note:** `StackAwsRole` is deprecated. Please use `AwsRole` instead. The functionality is identical. @@ -47,7 +49,7 @@ func NewStackAwsRole(ctx *pulumi.Context, if args.RoleArn == nil { return nil, errors.New("invalid value for required argument 'RoleArn'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource StackAwsRole err := ctx.RegisterResource("spacelift:index/stackAwsRole:StackAwsRole", name, args, &resource, opts...) if err != nil { @@ -157,6 +159,12 @@ func (i *StackAwsRole) ToStackAwsRoleOutputWithContext(ctx context.Context) Stac return pulumi.ToOutputWithContext(ctx, i).(StackAwsRoleOutput) } +func (i *StackAwsRole) ToOutput(ctx context.Context) pulumix.Output[*StackAwsRole] { + return pulumix.Output[*StackAwsRole]{ + OutputState: i.ToStackAwsRoleOutputWithContext(ctx).OutputState, + } +} + // StackAwsRoleArrayInput is an input type that accepts StackAwsRoleArray and StackAwsRoleArrayOutput values. // You can construct a concrete instance of `StackAwsRoleArrayInput` via: // @@ -182,6 +190,12 @@ func (i StackAwsRoleArray) ToStackAwsRoleArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(StackAwsRoleArrayOutput) } +func (i StackAwsRoleArray) ToOutput(ctx context.Context) pulumix.Output[[]*StackAwsRole] { + return pulumix.Output[[]*StackAwsRole]{ + OutputState: i.ToStackAwsRoleArrayOutputWithContext(ctx).OutputState, + } +} + // StackAwsRoleMapInput is an input type that accepts StackAwsRoleMap and StackAwsRoleMapOutput values. // You can construct a concrete instance of `StackAwsRoleMapInput` via: // @@ -207,6 +221,12 @@ func (i StackAwsRoleMap) ToStackAwsRoleMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(StackAwsRoleMapOutput) } +func (i StackAwsRoleMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackAwsRole] { + return pulumix.Output[map[string]*StackAwsRole]{ + OutputState: i.ToStackAwsRoleMapOutputWithContext(ctx).OutputState, + } +} + type StackAwsRoleOutput struct{ *pulumi.OutputState } func (StackAwsRoleOutput) ElementType() reflect.Type { @@ -221,6 +241,12 @@ func (o StackAwsRoleOutput) ToStackAwsRoleOutputWithContext(ctx context.Context) return o } +func (o StackAwsRoleOutput) ToOutput(ctx context.Context) pulumix.Output[*StackAwsRole] { + return pulumix.Output[*StackAwsRole]{ + OutputState: o.OutputState, + } +} + // AWS IAM role session duration in seconds func (o StackAwsRoleOutput) DurationSeconds() pulumi.IntOutput { return o.ApplyT(func(v *StackAwsRole) pulumi.IntOutput { return v.DurationSeconds }).(pulumi.IntOutput) @@ -265,6 +291,12 @@ func (o StackAwsRoleArrayOutput) ToStackAwsRoleArrayOutputWithContext(ctx contex return o } +func (o StackAwsRoleArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StackAwsRole] { + return pulumix.Output[[]*StackAwsRole]{ + OutputState: o.OutputState, + } +} + func (o StackAwsRoleArrayOutput) Index(i pulumi.IntInput) StackAwsRoleOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StackAwsRole { return vs[0].([]*StackAwsRole)[vs[1].(int)] @@ -285,6 +317,12 @@ func (o StackAwsRoleMapOutput) ToStackAwsRoleMapOutputWithContext(ctx context.Co return o } +func (o StackAwsRoleMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackAwsRole] { + return pulumix.Output[map[string]*StackAwsRole]{ + OutputState: o.OutputState, + } +} + func (o StackAwsRoleMapOutput) MapIndex(k pulumi.StringInput) StackAwsRoleOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StackAwsRole { return vs[0].(map[string]*StackAwsRole)[vs[1].(string)] diff --git a/sdk/go/spacelift/stackDependency.go b/sdk/go/spacelift/stackDependency.go new file mode 100644 index 0000000..91709c8 --- /dev/null +++ b/sdk/go/spacelift/stackDependency.go @@ -0,0 +1,315 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `StackDependency` represents a Spacelift **stack dependency** - a dependency between two stacks. When one stack depends on another, the tracked runs of the stack will not start until the dependent stack is successfully finished. Additionally, changes to the dependency will trigger the dependent. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// infra, err := spacelift.NewStack(ctx, "infra", &spacelift.StackArgs{ +// Branch: pulumi.String("master"), +// Repository: pulumi.String("core-infra"), +// }) +// if err != nil { +// return err +// } +// app, err := spacelift.NewStack(ctx, "app", &spacelift.StackArgs{ +// Branch: pulumi.String("master"), +// Repository: pulumi.String("app"), +// }) +// if err != nil { +// return err +// } +// _, err = spacelift.NewStackDependency(ctx, "test", &spacelift.StackDependencyArgs{ +// StackId: app.ID(), +// DependsOnStackId: infra.ID(), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type StackDependency struct { + pulumi.CustomResourceState + + // immutable ID (slug) of stack to depend on. + DependsOnStackId pulumi.StringOutput `pulumi:"dependsOnStackId"` + // immutable ID (slug) of stack which has a dependency. + StackId pulumi.StringOutput `pulumi:"stackId"` +} + +// NewStackDependency registers a new resource with the given unique name, arguments, and options. +func NewStackDependency(ctx *pulumi.Context, + name string, args *StackDependencyArgs, opts ...pulumi.ResourceOption) (*StackDependency, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.DependsOnStackId == nil { + return nil, errors.New("invalid value for required argument 'DependsOnStackId'") + } + if args.StackId == nil { + return nil, errors.New("invalid value for required argument 'StackId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource StackDependency + err := ctx.RegisterResource("spacelift:index/stackDependency:StackDependency", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetStackDependency gets an existing StackDependency resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetStackDependency(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *StackDependencyState, opts ...pulumi.ResourceOption) (*StackDependency, error) { + var resource StackDependency + err := ctx.ReadResource("spacelift:index/stackDependency:StackDependency", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering StackDependency resources. +type stackDependencyState struct { + // immutable ID (slug) of stack to depend on. + DependsOnStackId *string `pulumi:"dependsOnStackId"` + // immutable ID (slug) of stack which has a dependency. + StackId *string `pulumi:"stackId"` +} + +type StackDependencyState struct { + // immutable ID (slug) of stack to depend on. + DependsOnStackId pulumi.StringPtrInput + // immutable ID (slug) of stack which has a dependency. + StackId pulumi.StringPtrInput +} + +func (StackDependencyState) ElementType() reflect.Type { + return reflect.TypeOf((*stackDependencyState)(nil)).Elem() +} + +type stackDependencyArgs struct { + // immutable ID (slug) of stack to depend on. + DependsOnStackId string `pulumi:"dependsOnStackId"` + // immutable ID (slug) of stack which has a dependency. + StackId string `pulumi:"stackId"` +} + +// The set of arguments for constructing a StackDependency resource. +type StackDependencyArgs struct { + // immutable ID (slug) of stack to depend on. + DependsOnStackId pulumi.StringInput + // immutable ID (slug) of stack which has a dependency. + StackId pulumi.StringInput +} + +func (StackDependencyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*stackDependencyArgs)(nil)).Elem() +} + +type StackDependencyInput interface { + pulumi.Input + + ToStackDependencyOutput() StackDependencyOutput + ToStackDependencyOutputWithContext(ctx context.Context) StackDependencyOutput +} + +func (*StackDependency) ElementType() reflect.Type { + return reflect.TypeOf((**StackDependency)(nil)).Elem() +} + +func (i *StackDependency) ToStackDependencyOutput() StackDependencyOutput { + return i.ToStackDependencyOutputWithContext(context.Background()) +} + +func (i *StackDependency) ToStackDependencyOutputWithContext(ctx context.Context) StackDependencyOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackDependencyOutput) +} + +func (i *StackDependency) ToOutput(ctx context.Context) pulumix.Output[*StackDependency] { + return pulumix.Output[*StackDependency]{ + OutputState: i.ToStackDependencyOutputWithContext(ctx).OutputState, + } +} + +// StackDependencyArrayInput is an input type that accepts StackDependencyArray and StackDependencyArrayOutput values. +// You can construct a concrete instance of `StackDependencyArrayInput` via: +// +// StackDependencyArray{ StackDependencyArgs{...} } +type StackDependencyArrayInput interface { + pulumi.Input + + ToStackDependencyArrayOutput() StackDependencyArrayOutput + ToStackDependencyArrayOutputWithContext(context.Context) StackDependencyArrayOutput +} + +type StackDependencyArray []StackDependencyInput + +func (StackDependencyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*StackDependency)(nil)).Elem() +} + +func (i StackDependencyArray) ToStackDependencyArrayOutput() StackDependencyArrayOutput { + return i.ToStackDependencyArrayOutputWithContext(context.Background()) +} + +func (i StackDependencyArray) ToStackDependencyArrayOutputWithContext(ctx context.Context) StackDependencyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackDependencyArrayOutput) +} + +func (i StackDependencyArray) ToOutput(ctx context.Context) pulumix.Output[[]*StackDependency] { + return pulumix.Output[[]*StackDependency]{ + OutputState: i.ToStackDependencyArrayOutputWithContext(ctx).OutputState, + } +} + +// StackDependencyMapInput is an input type that accepts StackDependencyMap and StackDependencyMapOutput values. +// You can construct a concrete instance of `StackDependencyMapInput` via: +// +// StackDependencyMap{ "key": StackDependencyArgs{...} } +type StackDependencyMapInput interface { + pulumi.Input + + ToStackDependencyMapOutput() StackDependencyMapOutput + ToStackDependencyMapOutputWithContext(context.Context) StackDependencyMapOutput +} + +type StackDependencyMap map[string]StackDependencyInput + +func (StackDependencyMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*StackDependency)(nil)).Elem() +} + +func (i StackDependencyMap) ToStackDependencyMapOutput() StackDependencyMapOutput { + return i.ToStackDependencyMapOutputWithContext(context.Background()) +} + +func (i StackDependencyMap) ToStackDependencyMapOutputWithContext(ctx context.Context) StackDependencyMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackDependencyMapOutput) +} + +func (i StackDependencyMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackDependency] { + return pulumix.Output[map[string]*StackDependency]{ + OutputState: i.ToStackDependencyMapOutputWithContext(ctx).OutputState, + } +} + +type StackDependencyOutput struct{ *pulumi.OutputState } + +func (StackDependencyOutput) ElementType() reflect.Type { + return reflect.TypeOf((**StackDependency)(nil)).Elem() +} + +func (o StackDependencyOutput) ToStackDependencyOutput() StackDependencyOutput { + return o +} + +func (o StackDependencyOutput) ToStackDependencyOutputWithContext(ctx context.Context) StackDependencyOutput { + return o +} + +func (o StackDependencyOutput) ToOutput(ctx context.Context) pulumix.Output[*StackDependency] { + return pulumix.Output[*StackDependency]{ + OutputState: o.OutputState, + } +} + +// immutable ID (slug) of stack to depend on. +func (o StackDependencyOutput) DependsOnStackId() pulumi.StringOutput { + return o.ApplyT(func(v *StackDependency) pulumi.StringOutput { return v.DependsOnStackId }).(pulumi.StringOutput) +} + +// immutable ID (slug) of stack which has a dependency. +func (o StackDependencyOutput) StackId() pulumi.StringOutput { + return o.ApplyT(func(v *StackDependency) pulumi.StringOutput { return v.StackId }).(pulumi.StringOutput) +} + +type StackDependencyArrayOutput struct{ *pulumi.OutputState } + +func (StackDependencyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*StackDependency)(nil)).Elem() +} + +func (o StackDependencyArrayOutput) ToStackDependencyArrayOutput() StackDependencyArrayOutput { + return o +} + +func (o StackDependencyArrayOutput) ToStackDependencyArrayOutputWithContext(ctx context.Context) StackDependencyArrayOutput { + return o +} + +func (o StackDependencyArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StackDependency] { + return pulumix.Output[[]*StackDependency]{ + OutputState: o.OutputState, + } +} + +func (o StackDependencyArrayOutput) Index(i pulumi.IntInput) StackDependencyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StackDependency { + return vs[0].([]*StackDependency)[vs[1].(int)] + }).(StackDependencyOutput) +} + +type StackDependencyMapOutput struct{ *pulumi.OutputState } + +func (StackDependencyMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*StackDependency)(nil)).Elem() +} + +func (o StackDependencyMapOutput) ToStackDependencyMapOutput() StackDependencyMapOutput { + return o +} + +func (o StackDependencyMapOutput) ToStackDependencyMapOutputWithContext(ctx context.Context) StackDependencyMapOutput { + return o +} + +func (o StackDependencyMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackDependency] { + return pulumix.Output[map[string]*StackDependency]{ + OutputState: o.OutputState, + } +} + +func (o StackDependencyMapOutput) MapIndex(k pulumi.StringInput) StackDependencyOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StackDependency { + return vs[0].(map[string]*StackDependency)[vs[1].(string)] + }).(StackDependencyOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*StackDependencyInput)(nil)).Elem(), &StackDependency{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackDependencyArrayInput)(nil)).Elem(), StackDependencyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackDependencyMapInput)(nil)).Elem(), StackDependencyMap{}) + pulumi.RegisterOutputType(StackDependencyOutput{}) + pulumi.RegisterOutputType(StackDependencyArrayOutput{}) + pulumi.RegisterOutputType(StackDependencyMapOutput{}) +} diff --git a/sdk/go/spacelift/stackDependencyReference.go b/sdk/go/spacelift/stackDependencyReference.go new file mode 100644 index 0000000..a4b08b3 --- /dev/null +++ b/sdk/go/spacelift/stackDependencyReference.go @@ -0,0 +1,341 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `StackDependencyReference` represents a Spacelift **stack dependency reference** - a reference matches a stack's output to another stack's input. It is similar to an environment variable (`EnvironmentVariable`), except that value is provided by another stack's output. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// infra, err := spacelift.NewStack(ctx, "infra", &spacelift.StackArgs{ +// Branch: pulumi.String("master"), +// Repository: pulumi.String("core-infra"), +// }) +// if err != nil { +// return err +// } +// app, err := spacelift.NewStack(ctx, "app", &spacelift.StackArgs{ +// Branch: pulumi.String("master"), +// Repository: pulumi.String("app"), +// }) +// if err != nil { +// return err +// } +// testStackDependency, err := spacelift.NewStackDependency(ctx, "testStackDependency", &spacelift.StackDependencyArgs{ +// StackId: app.ID(), +// DependsOnStackId: infra.ID(), +// }) +// if err != nil { +// return err +// } +// _, err = spacelift.NewStackDependencyReference(ctx, "testStackDependencyReference", &spacelift.StackDependencyReferenceArgs{ +// StackDependencyId: testStackDependency.ID(), +// OutputName: pulumi.String("DB_CONNECTION_STRING"), +// InputName: pulumi.String("APP_DB_URL"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type StackDependencyReference struct { + pulumi.CustomResourceState + + // Name of the input of the stack dependency reference + InputName pulumi.StringOutput `pulumi:"inputName"` + // Name of the output of stack to depend on + OutputName pulumi.StringOutput `pulumi:"outputName"` + // Immutable ID of stack dependency + StackDependencyId pulumi.StringOutput `pulumi:"stackDependencyId"` +} + +// NewStackDependencyReference registers a new resource with the given unique name, arguments, and options. +func NewStackDependencyReference(ctx *pulumi.Context, + name string, args *StackDependencyReferenceArgs, opts ...pulumi.ResourceOption) (*StackDependencyReference, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InputName == nil { + return nil, errors.New("invalid value for required argument 'InputName'") + } + if args.OutputName == nil { + return nil, errors.New("invalid value for required argument 'OutputName'") + } + if args.StackDependencyId == nil { + return nil, errors.New("invalid value for required argument 'StackDependencyId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource StackDependencyReference + err := ctx.RegisterResource("spacelift:index/stackDependencyReference:StackDependencyReference", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetStackDependencyReference gets an existing StackDependencyReference resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetStackDependencyReference(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *StackDependencyReferenceState, opts ...pulumi.ResourceOption) (*StackDependencyReference, error) { + var resource StackDependencyReference + err := ctx.ReadResource("spacelift:index/stackDependencyReference:StackDependencyReference", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering StackDependencyReference resources. +type stackDependencyReferenceState struct { + // Name of the input of the stack dependency reference + InputName *string `pulumi:"inputName"` + // Name of the output of stack to depend on + OutputName *string `pulumi:"outputName"` + // Immutable ID of stack dependency + StackDependencyId *string `pulumi:"stackDependencyId"` +} + +type StackDependencyReferenceState struct { + // Name of the input of the stack dependency reference + InputName pulumi.StringPtrInput + // Name of the output of stack to depend on + OutputName pulumi.StringPtrInput + // Immutable ID of stack dependency + StackDependencyId pulumi.StringPtrInput +} + +func (StackDependencyReferenceState) ElementType() reflect.Type { + return reflect.TypeOf((*stackDependencyReferenceState)(nil)).Elem() +} + +type stackDependencyReferenceArgs struct { + // Name of the input of the stack dependency reference + InputName string `pulumi:"inputName"` + // Name of the output of stack to depend on + OutputName string `pulumi:"outputName"` + // Immutable ID of stack dependency + StackDependencyId string `pulumi:"stackDependencyId"` +} + +// The set of arguments for constructing a StackDependencyReference resource. +type StackDependencyReferenceArgs struct { + // Name of the input of the stack dependency reference + InputName pulumi.StringInput + // Name of the output of stack to depend on + OutputName pulumi.StringInput + // Immutable ID of stack dependency + StackDependencyId pulumi.StringInput +} + +func (StackDependencyReferenceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*stackDependencyReferenceArgs)(nil)).Elem() +} + +type StackDependencyReferenceInput interface { + pulumi.Input + + ToStackDependencyReferenceOutput() StackDependencyReferenceOutput + ToStackDependencyReferenceOutputWithContext(ctx context.Context) StackDependencyReferenceOutput +} + +func (*StackDependencyReference) ElementType() reflect.Type { + return reflect.TypeOf((**StackDependencyReference)(nil)).Elem() +} + +func (i *StackDependencyReference) ToStackDependencyReferenceOutput() StackDependencyReferenceOutput { + return i.ToStackDependencyReferenceOutputWithContext(context.Background()) +} + +func (i *StackDependencyReference) ToStackDependencyReferenceOutputWithContext(ctx context.Context) StackDependencyReferenceOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackDependencyReferenceOutput) +} + +func (i *StackDependencyReference) ToOutput(ctx context.Context) pulumix.Output[*StackDependencyReference] { + return pulumix.Output[*StackDependencyReference]{ + OutputState: i.ToStackDependencyReferenceOutputWithContext(ctx).OutputState, + } +} + +// StackDependencyReferenceArrayInput is an input type that accepts StackDependencyReferenceArray and StackDependencyReferenceArrayOutput values. +// You can construct a concrete instance of `StackDependencyReferenceArrayInput` via: +// +// StackDependencyReferenceArray{ StackDependencyReferenceArgs{...} } +type StackDependencyReferenceArrayInput interface { + pulumi.Input + + ToStackDependencyReferenceArrayOutput() StackDependencyReferenceArrayOutput + ToStackDependencyReferenceArrayOutputWithContext(context.Context) StackDependencyReferenceArrayOutput +} + +type StackDependencyReferenceArray []StackDependencyReferenceInput + +func (StackDependencyReferenceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*StackDependencyReference)(nil)).Elem() +} + +func (i StackDependencyReferenceArray) ToStackDependencyReferenceArrayOutput() StackDependencyReferenceArrayOutput { + return i.ToStackDependencyReferenceArrayOutputWithContext(context.Background()) +} + +func (i StackDependencyReferenceArray) ToStackDependencyReferenceArrayOutputWithContext(ctx context.Context) StackDependencyReferenceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackDependencyReferenceArrayOutput) +} + +func (i StackDependencyReferenceArray) ToOutput(ctx context.Context) pulumix.Output[[]*StackDependencyReference] { + return pulumix.Output[[]*StackDependencyReference]{ + OutputState: i.ToStackDependencyReferenceArrayOutputWithContext(ctx).OutputState, + } +} + +// StackDependencyReferenceMapInput is an input type that accepts StackDependencyReferenceMap and StackDependencyReferenceMapOutput values. +// You can construct a concrete instance of `StackDependencyReferenceMapInput` via: +// +// StackDependencyReferenceMap{ "key": StackDependencyReferenceArgs{...} } +type StackDependencyReferenceMapInput interface { + pulumi.Input + + ToStackDependencyReferenceMapOutput() StackDependencyReferenceMapOutput + ToStackDependencyReferenceMapOutputWithContext(context.Context) StackDependencyReferenceMapOutput +} + +type StackDependencyReferenceMap map[string]StackDependencyReferenceInput + +func (StackDependencyReferenceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*StackDependencyReference)(nil)).Elem() +} + +func (i StackDependencyReferenceMap) ToStackDependencyReferenceMapOutput() StackDependencyReferenceMapOutput { + return i.ToStackDependencyReferenceMapOutputWithContext(context.Background()) +} + +func (i StackDependencyReferenceMap) ToStackDependencyReferenceMapOutputWithContext(ctx context.Context) StackDependencyReferenceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(StackDependencyReferenceMapOutput) +} + +func (i StackDependencyReferenceMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackDependencyReference] { + return pulumix.Output[map[string]*StackDependencyReference]{ + OutputState: i.ToStackDependencyReferenceMapOutputWithContext(ctx).OutputState, + } +} + +type StackDependencyReferenceOutput struct{ *pulumi.OutputState } + +func (StackDependencyReferenceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**StackDependencyReference)(nil)).Elem() +} + +func (o StackDependencyReferenceOutput) ToStackDependencyReferenceOutput() StackDependencyReferenceOutput { + return o +} + +func (o StackDependencyReferenceOutput) ToStackDependencyReferenceOutputWithContext(ctx context.Context) StackDependencyReferenceOutput { + return o +} + +func (o StackDependencyReferenceOutput) ToOutput(ctx context.Context) pulumix.Output[*StackDependencyReference] { + return pulumix.Output[*StackDependencyReference]{ + OutputState: o.OutputState, + } +} + +// Name of the input of the stack dependency reference +func (o StackDependencyReferenceOutput) InputName() pulumi.StringOutput { + return o.ApplyT(func(v *StackDependencyReference) pulumi.StringOutput { return v.InputName }).(pulumi.StringOutput) +} + +// Name of the output of stack to depend on +func (o StackDependencyReferenceOutput) OutputName() pulumi.StringOutput { + return o.ApplyT(func(v *StackDependencyReference) pulumi.StringOutput { return v.OutputName }).(pulumi.StringOutput) +} + +// Immutable ID of stack dependency +func (o StackDependencyReferenceOutput) StackDependencyId() pulumi.StringOutput { + return o.ApplyT(func(v *StackDependencyReference) pulumi.StringOutput { return v.StackDependencyId }).(pulumi.StringOutput) +} + +type StackDependencyReferenceArrayOutput struct{ *pulumi.OutputState } + +func (StackDependencyReferenceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*StackDependencyReference)(nil)).Elem() +} + +func (o StackDependencyReferenceArrayOutput) ToStackDependencyReferenceArrayOutput() StackDependencyReferenceArrayOutput { + return o +} + +func (o StackDependencyReferenceArrayOutput) ToStackDependencyReferenceArrayOutputWithContext(ctx context.Context) StackDependencyReferenceArrayOutput { + return o +} + +func (o StackDependencyReferenceArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StackDependencyReference] { + return pulumix.Output[[]*StackDependencyReference]{ + OutputState: o.OutputState, + } +} + +func (o StackDependencyReferenceArrayOutput) Index(i pulumi.IntInput) StackDependencyReferenceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StackDependencyReference { + return vs[0].([]*StackDependencyReference)[vs[1].(int)] + }).(StackDependencyReferenceOutput) +} + +type StackDependencyReferenceMapOutput struct{ *pulumi.OutputState } + +func (StackDependencyReferenceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*StackDependencyReference)(nil)).Elem() +} + +func (o StackDependencyReferenceMapOutput) ToStackDependencyReferenceMapOutput() StackDependencyReferenceMapOutput { + return o +} + +func (o StackDependencyReferenceMapOutput) ToStackDependencyReferenceMapOutputWithContext(ctx context.Context) StackDependencyReferenceMapOutput { + return o +} + +func (o StackDependencyReferenceMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackDependencyReference] { + return pulumix.Output[map[string]*StackDependencyReference]{ + OutputState: o.OutputState, + } +} + +func (o StackDependencyReferenceMapOutput) MapIndex(k pulumi.StringInput) StackDependencyReferenceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StackDependencyReference { + return vs[0].(map[string]*StackDependencyReference)[vs[1].(string)] + }).(StackDependencyReferenceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*StackDependencyReferenceInput)(nil)).Elem(), &StackDependencyReference{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackDependencyReferenceArrayInput)(nil)).Elem(), StackDependencyReferenceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*StackDependencyReferenceMapInput)(nil)).Elem(), StackDependencyReferenceMap{}) + pulumi.RegisterOutputType(StackDependencyReferenceOutput{}) + pulumi.RegisterOutputType(StackDependencyReferenceArrayOutput{}) + pulumi.RegisterOutputType(StackDependencyReferenceMapOutput{}) +} diff --git a/sdk/go/spacelift/stackDestructor.go b/sdk/go/spacelift/stackDestructor.go index f4b0d55..553476b 100644 --- a/sdk/go/spacelift/stackDestructor.go +++ b/sdk/go/spacelift/stackDestructor.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `StackDestructor` is used to destroy the resources of a Stack before deleting it. `dependsOn` should be used to make sure that all necessary resources (environment variables, roles, integrations, etc.) are still in place when the destruction run is executed. **Note:** Destroying this resource will delete the resources in the stack. If this resource needs to be deleted and the resources in the stacks are to be preserved, ensure that the `deactivated` attribute is set to `true`. @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -67,7 +69,7 @@ func NewStackDestructor(ctx *pulumi.Context, if args.StackId == nil { return nil, errors.New("invalid value for required argument 'StackId'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource StackDestructor err := ctx.RegisterResource("spacelift:index/stackDestructor:StackDestructor", name, args, &resource, opts...) if err != nil { @@ -145,6 +147,12 @@ func (i *StackDestructor) ToStackDestructorOutputWithContext(ctx context.Context return pulumi.ToOutputWithContext(ctx, i).(StackDestructorOutput) } +func (i *StackDestructor) ToOutput(ctx context.Context) pulumix.Output[*StackDestructor] { + return pulumix.Output[*StackDestructor]{ + OutputState: i.ToStackDestructorOutputWithContext(ctx).OutputState, + } +} + // StackDestructorArrayInput is an input type that accepts StackDestructorArray and StackDestructorArrayOutput values. // You can construct a concrete instance of `StackDestructorArrayInput` via: // @@ -170,6 +178,12 @@ func (i StackDestructorArray) ToStackDestructorArrayOutputWithContext(ctx contex return pulumi.ToOutputWithContext(ctx, i).(StackDestructorArrayOutput) } +func (i StackDestructorArray) ToOutput(ctx context.Context) pulumix.Output[[]*StackDestructor] { + return pulumix.Output[[]*StackDestructor]{ + OutputState: i.ToStackDestructorArrayOutputWithContext(ctx).OutputState, + } +} + // StackDestructorMapInput is an input type that accepts StackDestructorMap and StackDestructorMapOutput values. // You can construct a concrete instance of `StackDestructorMapInput` via: // @@ -195,6 +209,12 @@ func (i StackDestructorMap) ToStackDestructorMapOutputWithContext(ctx context.Co return pulumi.ToOutputWithContext(ctx, i).(StackDestructorMapOutput) } +func (i StackDestructorMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackDestructor] { + return pulumix.Output[map[string]*StackDestructor]{ + OutputState: i.ToStackDestructorMapOutputWithContext(ctx).OutputState, + } +} + type StackDestructorOutput struct{ *pulumi.OutputState } func (StackDestructorOutput) ElementType() reflect.Type { @@ -209,6 +229,12 @@ func (o StackDestructorOutput) ToStackDestructorOutputWithContext(ctx context.Co return o } +func (o StackDestructorOutput) ToOutput(ctx context.Context) pulumix.Output[*StackDestructor] { + return pulumix.Output[*StackDestructor]{ + OutputState: o.OutputState, + } +} + // If set to true, destruction won't delete the stack func (o StackDestructorOutput) Deactivated() pulumi.BoolPtrOutput { return o.ApplyT(func(v *StackDestructor) pulumi.BoolPtrOutput { return v.Deactivated }).(pulumi.BoolPtrOutput) @@ -233,6 +259,12 @@ func (o StackDestructorArrayOutput) ToStackDestructorArrayOutputWithContext(ctx return o } +func (o StackDestructorArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StackDestructor] { + return pulumix.Output[[]*StackDestructor]{ + OutputState: o.OutputState, + } +} + func (o StackDestructorArrayOutput) Index(i pulumi.IntInput) StackDestructorOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StackDestructor { return vs[0].([]*StackDestructor)[vs[1].(int)] @@ -253,6 +285,12 @@ func (o StackDestructorMapOutput) ToStackDestructorMapOutputWithContext(ctx cont return o } +func (o StackDestructorMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackDestructor] { + return pulumix.Output[map[string]*StackDestructor]{ + OutputState: o.OutputState, + } +} + func (o StackDestructorMapOutput) MapIndex(k pulumi.StringInput) StackDestructorOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StackDestructor { return vs[0].(map[string]*StackDestructor)[vs[1].(string)] diff --git a/sdk/go/spacelift/stackGcpServiceAccount.go b/sdk/go/spacelift/stackGcpServiceAccount.go index ce64986..e5c494b 100644 --- a/sdk/go/spacelift/stackGcpServiceAccount.go +++ b/sdk/go/spacelift/stackGcpServiceAccount.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // ## Example Usage @@ -20,10 +22,9 @@ import ( // // "fmt" // -// "github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/organizations" -// "github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/projects" +// "github.com/pulumi/pulumi-google/sdk/v1/go/google" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -47,19 +48,18 @@ import ( // if err != nil { // return err // } -// _, err = organizations.NewProject(ctx, "k8s-coreProject", &organizations.ProjectArgs{ -// ProjectId: pulumi.String("unicorn-k8s-core"), -// OrgId: pulumi.Any(_var.Gcp_organization_id), +// _, err = index.NewGoogle_project(ctx, "k8s-coregoogle_project", &index.Google_projectArgs{ +// Name: "Kubernetes code", +// ProjectId: "unicorn-k8s-core", +// OrgId: _var.Gcp_organization_id, // }) // if err != nil { // return err // } -// _, err = projects.NewIAMMember(ctx, "k8s-coreIAMMember", &projects.IAMMemberArgs{ -// Project: k8s_coreProject.ID(), -// Role: pulumi.String("roles/owner"), -// Member: k8s_coreStackGcpServiceAccount.ServiceAccountEmail.ApplyT(func(serviceAccountEmail string) (string, error) { -// return fmt.Sprintf("serviceAccount:%v", serviceAccountEmail), nil -// }).(pulumi.StringOutput), +// _, err = index.NewGoogle_project_iam_member(ctx, "k8s-coregoogle_project_iam_member", &index.Google_project_iam_memberArgs{ +// Project: k8s_coregoogle_project.Id, +// Role: "roles/owner", +// Member: pulumi.String(fmt.Sprintf("serviceAccount:%v", k8s_coreStackGcpServiceAccount.ServiceAccountEmail)), // }) // if err != nil { // return err @@ -92,7 +92,7 @@ func NewStackGcpServiceAccount(ctx *pulumi.Context, if args.TokenScopes == nil { return nil, errors.New("invalid value for required argument 'TokenScopes'") } - opts = pkgResourceDefaultOpts(opts) + opts = internal.PkgResourceDefaultOpts(opts) var resource StackGcpServiceAccount err := ctx.RegisterResource("spacelift:index/stackGcpServiceAccount:StackGcpServiceAccount", name, args, &resource, opts...) if err != nil { @@ -182,6 +182,12 @@ func (i *StackGcpServiceAccount) ToStackGcpServiceAccountOutputWithContext(ctx c return pulumi.ToOutputWithContext(ctx, i).(StackGcpServiceAccountOutput) } +func (i *StackGcpServiceAccount) ToOutput(ctx context.Context) pulumix.Output[*StackGcpServiceAccount] { + return pulumix.Output[*StackGcpServiceAccount]{ + OutputState: i.ToStackGcpServiceAccountOutputWithContext(ctx).OutputState, + } +} + // StackGcpServiceAccountArrayInput is an input type that accepts StackGcpServiceAccountArray and StackGcpServiceAccountArrayOutput values. // You can construct a concrete instance of `StackGcpServiceAccountArrayInput` via: // @@ -207,6 +213,12 @@ func (i StackGcpServiceAccountArray) ToStackGcpServiceAccountArrayOutputWithCont return pulumi.ToOutputWithContext(ctx, i).(StackGcpServiceAccountArrayOutput) } +func (i StackGcpServiceAccountArray) ToOutput(ctx context.Context) pulumix.Output[[]*StackGcpServiceAccount] { + return pulumix.Output[[]*StackGcpServiceAccount]{ + OutputState: i.ToStackGcpServiceAccountArrayOutputWithContext(ctx).OutputState, + } +} + // StackGcpServiceAccountMapInput is an input type that accepts StackGcpServiceAccountMap and StackGcpServiceAccountMapOutput values. // You can construct a concrete instance of `StackGcpServiceAccountMapInput` via: // @@ -232,6 +244,12 @@ func (i StackGcpServiceAccountMap) ToStackGcpServiceAccountMapOutputWithContext( return pulumi.ToOutputWithContext(ctx, i).(StackGcpServiceAccountMapOutput) } +func (i StackGcpServiceAccountMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackGcpServiceAccount] { + return pulumix.Output[map[string]*StackGcpServiceAccount]{ + OutputState: i.ToStackGcpServiceAccountMapOutputWithContext(ctx).OutputState, + } +} + type StackGcpServiceAccountOutput struct{ *pulumi.OutputState } func (StackGcpServiceAccountOutput) ElementType() reflect.Type { @@ -246,6 +264,12 @@ func (o StackGcpServiceAccountOutput) ToStackGcpServiceAccountOutputWithContext( return o } +func (o StackGcpServiceAccountOutput) ToOutput(ctx context.Context) pulumix.Output[*StackGcpServiceAccount] { + return pulumix.Output[*StackGcpServiceAccount]{ + OutputState: o.OutputState, + } +} + // ID of the module which uses GCP service account credentials func (o StackGcpServiceAccountOutput) ModuleId() pulumi.StringPtrOutput { return o.ApplyT(func(v *StackGcpServiceAccount) pulumi.StringPtrOutput { return v.ModuleId }).(pulumi.StringPtrOutput) @@ -280,6 +304,12 @@ func (o StackGcpServiceAccountArrayOutput) ToStackGcpServiceAccountArrayOutputWi return o } +func (o StackGcpServiceAccountArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*StackGcpServiceAccount] { + return pulumix.Output[[]*StackGcpServiceAccount]{ + OutputState: o.OutputState, + } +} + func (o StackGcpServiceAccountArrayOutput) Index(i pulumi.IntInput) StackGcpServiceAccountOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *StackGcpServiceAccount { return vs[0].([]*StackGcpServiceAccount)[vs[1].(int)] @@ -300,6 +330,12 @@ func (o StackGcpServiceAccountMapOutput) ToStackGcpServiceAccountMapOutputWithCo return o } +func (o StackGcpServiceAccountMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*StackGcpServiceAccount] { + return pulumix.Output[map[string]*StackGcpServiceAccount]{ + OutputState: o.OutputState, + } +} + func (o StackGcpServiceAccountMapOutput) MapIndex(k pulumi.StringInput) StackGcpServiceAccountOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *StackGcpServiceAccount { return vs[0].(map[string]*StackGcpServiceAccount)[vs[1].(string)] diff --git a/sdk/go/spacelift/terraformProvider.go b/sdk/go/spacelift/terraformProvider.go new file mode 100644 index 0000000..18bfbb5 --- /dev/null +++ b/sdk/go/spacelift/terraformProvider.go @@ -0,0 +1,343 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := spacelift.NewTerraformProvider(ctx, "datadog", &spacelift.TerraformProviderArgs{ +// Description: pulumi.String("Our fork of the Datadog provider"), +// Labels: pulumi.StringArray{ +// pulumi.String("fork"), +// }, +// Public: pulumi.Bool(false), +// SpaceId: pulumi.String("root"), +// Type: pulumi.String("datadog"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type TerraformProvider struct { + pulumi.CustomResourceState + + // Free-form description for human users, supports Markdown + Description pulumi.StringPtrOutput `pulumi:"description"` + Labels pulumi.StringArrayOutput `pulumi:"labels"` + // Whether the provider is public or not, defaults to false (private) + Public pulumi.BoolPtrOutput `pulumi:"public"` + // ID (slug) of the space the provider is in + SpaceId pulumi.StringOutput `pulumi:"spaceId"` + // Type of the provider - should be unique in one account + Type pulumi.StringOutput `pulumi:"type"` +} + +// NewTerraformProvider registers a new resource with the given unique name, arguments, and options. +func NewTerraformProvider(ctx *pulumi.Context, + name string, args *TerraformProviderArgs, opts ...pulumi.ResourceOption) (*TerraformProvider, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SpaceId == nil { + return nil, errors.New("invalid value for required argument 'SpaceId'") + } + if args.Type == nil { + return nil, errors.New("invalid value for required argument 'Type'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource TerraformProvider + err := ctx.RegisterResource("spacelift:index/terraformProvider:TerraformProvider", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetTerraformProvider gets an existing TerraformProvider resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetTerraformProvider(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *TerraformProviderState, opts ...pulumi.ResourceOption) (*TerraformProvider, error) { + var resource TerraformProvider + err := ctx.ReadResource("spacelift:index/terraformProvider:TerraformProvider", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering TerraformProvider resources. +type terraformProviderState struct { + // Free-form description for human users, supports Markdown + Description *string `pulumi:"description"` + Labels []string `pulumi:"labels"` + // Whether the provider is public or not, defaults to false (private) + Public *bool `pulumi:"public"` + // ID (slug) of the space the provider is in + SpaceId *string `pulumi:"spaceId"` + // Type of the provider - should be unique in one account + Type *string `pulumi:"type"` +} + +type TerraformProviderState struct { + // Free-form description for human users, supports Markdown + Description pulumi.StringPtrInput + Labels pulumi.StringArrayInput + // Whether the provider is public or not, defaults to false (private) + Public pulumi.BoolPtrInput + // ID (slug) of the space the provider is in + SpaceId pulumi.StringPtrInput + // Type of the provider - should be unique in one account + Type pulumi.StringPtrInput +} + +func (TerraformProviderState) ElementType() reflect.Type { + return reflect.TypeOf((*terraformProviderState)(nil)).Elem() +} + +type terraformProviderArgs struct { + // Free-form description for human users, supports Markdown + Description *string `pulumi:"description"` + Labels []string `pulumi:"labels"` + // Whether the provider is public or not, defaults to false (private) + Public *bool `pulumi:"public"` + // ID (slug) of the space the provider is in + SpaceId string `pulumi:"spaceId"` + // Type of the provider - should be unique in one account + Type string `pulumi:"type"` +} + +// The set of arguments for constructing a TerraformProvider resource. +type TerraformProviderArgs struct { + // Free-form description for human users, supports Markdown + Description pulumi.StringPtrInput + Labels pulumi.StringArrayInput + // Whether the provider is public or not, defaults to false (private) + Public pulumi.BoolPtrInput + // ID (slug) of the space the provider is in + SpaceId pulumi.StringInput + // Type of the provider - should be unique in one account + Type pulumi.StringInput +} + +func (TerraformProviderArgs) ElementType() reflect.Type { + return reflect.TypeOf((*terraformProviderArgs)(nil)).Elem() +} + +type TerraformProviderInput interface { + pulumi.Input + + ToTerraformProviderOutput() TerraformProviderOutput + ToTerraformProviderOutputWithContext(ctx context.Context) TerraformProviderOutput +} + +func (*TerraformProvider) ElementType() reflect.Type { + return reflect.TypeOf((**TerraformProvider)(nil)).Elem() +} + +func (i *TerraformProvider) ToTerraformProviderOutput() TerraformProviderOutput { + return i.ToTerraformProviderOutputWithContext(context.Background()) +} + +func (i *TerraformProvider) ToTerraformProviderOutputWithContext(ctx context.Context) TerraformProviderOutput { + return pulumi.ToOutputWithContext(ctx, i).(TerraformProviderOutput) +} + +func (i *TerraformProvider) ToOutput(ctx context.Context) pulumix.Output[*TerraformProvider] { + return pulumix.Output[*TerraformProvider]{ + OutputState: i.ToTerraformProviderOutputWithContext(ctx).OutputState, + } +} + +// TerraformProviderArrayInput is an input type that accepts TerraformProviderArray and TerraformProviderArrayOutput values. +// You can construct a concrete instance of `TerraformProviderArrayInput` via: +// +// TerraformProviderArray{ TerraformProviderArgs{...} } +type TerraformProviderArrayInput interface { + pulumi.Input + + ToTerraformProviderArrayOutput() TerraformProviderArrayOutput + ToTerraformProviderArrayOutputWithContext(context.Context) TerraformProviderArrayOutput +} + +type TerraformProviderArray []TerraformProviderInput + +func (TerraformProviderArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TerraformProvider)(nil)).Elem() +} + +func (i TerraformProviderArray) ToTerraformProviderArrayOutput() TerraformProviderArrayOutput { + return i.ToTerraformProviderArrayOutputWithContext(context.Background()) +} + +func (i TerraformProviderArray) ToTerraformProviderArrayOutputWithContext(ctx context.Context) TerraformProviderArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TerraformProviderArrayOutput) +} + +func (i TerraformProviderArray) ToOutput(ctx context.Context) pulumix.Output[[]*TerraformProvider] { + return pulumix.Output[[]*TerraformProvider]{ + OutputState: i.ToTerraformProviderArrayOutputWithContext(ctx).OutputState, + } +} + +// TerraformProviderMapInput is an input type that accepts TerraformProviderMap and TerraformProviderMapOutput values. +// You can construct a concrete instance of `TerraformProviderMapInput` via: +// +// TerraformProviderMap{ "key": TerraformProviderArgs{...} } +type TerraformProviderMapInput interface { + pulumi.Input + + ToTerraformProviderMapOutput() TerraformProviderMapOutput + ToTerraformProviderMapOutputWithContext(context.Context) TerraformProviderMapOutput +} + +type TerraformProviderMap map[string]TerraformProviderInput + +func (TerraformProviderMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TerraformProvider)(nil)).Elem() +} + +func (i TerraformProviderMap) ToTerraformProviderMapOutput() TerraformProviderMapOutput { + return i.ToTerraformProviderMapOutputWithContext(context.Background()) +} + +func (i TerraformProviderMap) ToTerraformProviderMapOutputWithContext(ctx context.Context) TerraformProviderMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(TerraformProviderMapOutput) +} + +func (i TerraformProviderMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*TerraformProvider] { + return pulumix.Output[map[string]*TerraformProvider]{ + OutputState: i.ToTerraformProviderMapOutputWithContext(ctx).OutputState, + } +} + +type TerraformProviderOutput struct{ *pulumi.OutputState } + +func (TerraformProviderOutput) ElementType() reflect.Type { + return reflect.TypeOf((**TerraformProvider)(nil)).Elem() +} + +func (o TerraformProviderOutput) ToTerraformProviderOutput() TerraformProviderOutput { + return o +} + +func (o TerraformProviderOutput) ToTerraformProviderOutputWithContext(ctx context.Context) TerraformProviderOutput { + return o +} + +func (o TerraformProviderOutput) ToOutput(ctx context.Context) pulumix.Output[*TerraformProvider] { + return pulumix.Output[*TerraformProvider]{ + OutputState: o.OutputState, + } +} + +// Free-form description for human users, supports Markdown +func (o TerraformProviderOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *TerraformProvider) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o TerraformProviderOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v *TerraformProvider) pulumi.StringArrayOutput { return v.Labels }).(pulumi.StringArrayOutput) +} + +// Whether the provider is public or not, defaults to false (private) +func (o TerraformProviderOutput) Public() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *TerraformProvider) pulumi.BoolPtrOutput { return v.Public }).(pulumi.BoolPtrOutput) +} + +// ID (slug) of the space the provider is in +func (o TerraformProviderOutput) SpaceId() pulumi.StringOutput { + return o.ApplyT(func(v *TerraformProvider) pulumi.StringOutput { return v.SpaceId }).(pulumi.StringOutput) +} + +// Type of the provider - should be unique in one account +func (o TerraformProviderOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v *TerraformProvider) pulumi.StringOutput { return v.Type }).(pulumi.StringOutput) +} + +type TerraformProviderArrayOutput struct{ *pulumi.OutputState } + +func (TerraformProviderArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TerraformProvider)(nil)).Elem() +} + +func (o TerraformProviderArrayOutput) ToTerraformProviderArrayOutput() TerraformProviderArrayOutput { + return o +} + +func (o TerraformProviderArrayOutput) ToTerraformProviderArrayOutputWithContext(ctx context.Context) TerraformProviderArrayOutput { + return o +} + +func (o TerraformProviderArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*TerraformProvider] { + return pulumix.Output[[]*TerraformProvider]{ + OutputState: o.OutputState, + } +} + +func (o TerraformProviderArrayOutput) Index(i pulumi.IntInput) TerraformProviderOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *TerraformProvider { + return vs[0].([]*TerraformProvider)[vs[1].(int)] + }).(TerraformProviderOutput) +} + +type TerraformProviderMapOutput struct{ *pulumi.OutputState } + +func (TerraformProviderMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TerraformProvider)(nil)).Elem() +} + +func (o TerraformProviderMapOutput) ToTerraformProviderMapOutput() TerraformProviderMapOutput { + return o +} + +func (o TerraformProviderMapOutput) ToTerraformProviderMapOutputWithContext(ctx context.Context) TerraformProviderMapOutput { + return o +} + +func (o TerraformProviderMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*TerraformProvider] { + return pulumix.Output[map[string]*TerraformProvider]{ + OutputState: o.OutputState, + } +} + +func (o TerraformProviderMapOutput) MapIndex(k pulumi.StringInput) TerraformProviderOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *TerraformProvider { + return vs[0].(map[string]*TerraformProvider)[vs[1].(string)] + }).(TerraformProviderOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*TerraformProviderInput)(nil)).Elem(), &TerraformProvider{}) + pulumi.RegisterInputType(reflect.TypeOf((*TerraformProviderArrayInput)(nil)).Elem(), TerraformProviderArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*TerraformProviderMapInput)(nil)).Elem(), TerraformProviderMap{}) + pulumi.RegisterOutputType(TerraformProviderOutput{}) + pulumi.RegisterOutputType(TerraformProviderArrayOutput{}) + pulumi.RegisterOutputType(TerraformProviderMapOutput{}) +} diff --git a/sdk/go/spacelift/user.go b/sdk/go/spacelift/user.go new file mode 100644 index 0000000..6ddaa3c --- /dev/null +++ b/sdk/go/spacelift/user.go @@ -0,0 +1,286 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `User` represents a mapping between a Spacelift user (managed using an Identity Provider) and a Policy. A Policy defines what access rights the user has to a given Space. +type User struct { + pulumi.CustomResourceState + + // Email of the user. Used for sending an invitation. + InvitationEmail pulumi.StringOutput `pulumi:"invitationEmail"` + Policies UserPolicyArrayOutput `pulumi:"policies"` + // Username of the user + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewUser registers a new resource with the given unique name, arguments, and options. +func NewUser(ctx *pulumi.Context, + name string, args *UserArgs, opts ...pulumi.ResourceOption) (*User, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InvitationEmail == nil { + return nil, errors.New("invalid value for required argument 'InvitationEmail'") + } + if args.Policies == nil { + return nil, errors.New("invalid value for required argument 'Policies'") + } + if args.Username == nil { + return nil, errors.New("invalid value for required argument 'Username'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource User + err := ctx.RegisterResource("spacelift:index/user:User", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetUser gets an existing User resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetUser(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *UserState, opts ...pulumi.ResourceOption) (*User, error) { + var resource User + err := ctx.ReadResource("spacelift:index/user:User", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering User resources. +type userState struct { + // Email of the user. Used for sending an invitation. + InvitationEmail *string `pulumi:"invitationEmail"` + Policies []UserPolicy `pulumi:"policies"` + // Username of the user + Username *string `pulumi:"username"` +} + +type UserState struct { + // Email of the user. Used for sending an invitation. + InvitationEmail pulumi.StringPtrInput + Policies UserPolicyArrayInput + // Username of the user + Username pulumi.StringPtrInput +} + +func (UserState) ElementType() reflect.Type { + return reflect.TypeOf((*userState)(nil)).Elem() +} + +type userArgs struct { + // Email of the user. Used for sending an invitation. + InvitationEmail string `pulumi:"invitationEmail"` + Policies []UserPolicy `pulumi:"policies"` + // Username of the user + Username string `pulumi:"username"` +} + +// The set of arguments for constructing a User resource. +type UserArgs struct { + // Email of the user. Used for sending an invitation. + InvitationEmail pulumi.StringInput + Policies UserPolicyArrayInput + // Username of the user + Username pulumi.StringInput +} + +func (UserArgs) ElementType() reflect.Type { + return reflect.TypeOf((*userArgs)(nil)).Elem() +} + +type UserInput interface { + pulumi.Input + + ToUserOutput() UserOutput + ToUserOutputWithContext(ctx context.Context) UserOutput +} + +func (*User) ElementType() reflect.Type { + return reflect.TypeOf((**User)(nil)).Elem() +} + +func (i *User) ToUserOutput() UserOutput { + return i.ToUserOutputWithContext(context.Background()) +} + +func (i *User) ToUserOutputWithContext(ctx context.Context) UserOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserOutput) +} + +func (i *User) ToOutput(ctx context.Context) pulumix.Output[*User] { + return pulumix.Output[*User]{ + OutputState: i.ToUserOutputWithContext(ctx).OutputState, + } +} + +// UserArrayInput is an input type that accepts UserArray and UserArrayOutput values. +// You can construct a concrete instance of `UserArrayInput` via: +// +// UserArray{ UserArgs{...} } +type UserArrayInput interface { + pulumi.Input + + ToUserArrayOutput() UserArrayOutput + ToUserArrayOutputWithContext(context.Context) UserArrayOutput +} + +type UserArray []UserInput + +func (UserArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*User)(nil)).Elem() +} + +func (i UserArray) ToUserArrayOutput() UserArrayOutput { + return i.ToUserArrayOutputWithContext(context.Background()) +} + +func (i UserArray) ToUserArrayOutputWithContext(ctx context.Context) UserArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserArrayOutput) +} + +func (i UserArray) ToOutput(ctx context.Context) pulumix.Output[[]*User] { + return pulumix.Output[[]*User]{ + OutputState: i.ToUserArrayOutputWithContext(ctx).OutputState, + } +} + +// UserMapInput is an input type that accepts UserMap and UserMapOutput values. +// You can construct a concrete instance of `UserMapInput` via: +// +// UserMap{ "key": UserArgs{...} } +type UserMapInput interface { + pulumi.Input + + ToUserMapOutput() UserMapOutput + ToUserMapOutputWithContext(context.Context) UserMapOutput +} + +type UserMap map[string]UserInput + +func (UserMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*User)(nil)).Elem() +} + +func (i UserMap) ToUserMapOutput() UserMapOutput { + return i.ToUserMapOutputWithContext(context.Background()) +} + +func (i UserMap) ToUserMapOutputWithContext(ctx context.Context) UserMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserMapOutput) +} + +func (i UserMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*User] { + return pulumix.Output[map[string]*User]{ + OutputState: i.ToUserMapOutputWithContext(ctx).OutputState, + } +} + +type UserOutput struct{ *pulumi.OutputState } + +func (UserOutput) ElementType() reflect.Type { + return reflect.TypeOf((**User)(nil)).Elem() +} + +func (o UserOutput) ToUserOutput() UserOutput { + return o +} + +func (o UserOutput) ToUserOutputWithContext(ctx context.Context) UserOutput { + return o +} + +func (o UserOutput) ToOutput(ctx context.Context) pulumix.Output[*User] { + return pulumix.Output[*User]{ + OutputState: o.OutputState, + } +} + +// Email of the user. Used for sending an invitation. +func (o UserOutput) InvitationEmail() pulumi.StringOutput { + return o.ApplyT(func(v *User) pulumi.StringOutput { return v.InvitationEmail }).(pulumi.StringOutput) +} + +func (o UserOutput) Policies() UserPolicyArrayOutput { + return o.ApplyT(func(v *User) UserPolicyArrayOutput { return v.Policies }).(UserPolicyArrayOutput) +} + +// Username of the user +func (o UserOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *User) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type UserArrayOutput struct{ *pulumi.OutputState } + +func (UserArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*User)(nil)).Elem() +} + +func (o UserArrayOutput) ToUserArrayOutput() UserArrayOutput { + return o +} + +func (o UserArrayOutput) ToUserArrayOutputWithContext(ctx context.Context) UserArrayOutput { + return o +} + +func (o UserArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*User] { + return pulumix.Output[[]*User]{ + OutputState: o.OutputState, + } +} + +func (o UserArrayOutput) Index(i pulumi.IntInput) UserOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *User { + return vs[0].([]*User)[vs[1].(int)] + }).(UserOutput) +} + +type UserMapOutput struct{ *pulumi.OutputState } + +func (UserMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*User)(nil)).Elem() +} + +func (o UserMapOutput) ToUserMapOutput() UserMapOutput { + return o +} + +func (o UserMapOutput) ToUserMapOutputWithContext(ctx context.Context) UserMapOutput { + return o +} + +func (o UserMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*User] { + return pulumix.Output[map[string]*User]{ + OutputState: o.OutputState, + } +} + +func (o UserMapOutput) MapIndex(k pulumi.StringInput) UserOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *User { + return vs[0].(map[string]*User)[vs[1].(string)] + }).(UserOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*UserInput)(nil)).Elem(), &User{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserArrayInput)(nil)).Elem(), UserArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserMapInput)(nil)).Elem(), UserMap{}) + pulumi.RegisterOutputType(UserOutput{}) + pulumi.RegisterOutputType(UserArrayOutput{}) + pulumi.RegisterOutputType(UserMapOutput{}) +} diff --git a/sdk/go/spacelift/vcsAgentPool.go b/sdk/go/spacelift/vcsAgentPool.go index 6304ca6..dc4cc9a 100644 --- a/sdk/go/spacelift/vcsAgentPool.go +++ b/sdk/go/spacelift/vcsAgentPool.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `VcsAgentPool` represents a Spacelift **VCS agent pool** - a logical group of proxies allowing Spacelift to access private VCS installations @@ -20,7 +22,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -63,7 +65,11 @@ func NewVcsAgentPool(ctx *pulumi.Context, args = &VcsAgentPoolArgs{} } - opts = pkgResourceDefaultOpts(opts) + secrets := pulumi.AdditionalSecretOutputs([]string{ + "config", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) var resource VcsAgentPool err := ctx.RegisterResource("spacelift:index/vcsAgentPool:VcsAgentPool", name, args, &resource, opts...) if err != nil { @@ -145,6 +151,12 @@ func (i *VcsAgentPool) ToVcsAgentPoolOutputWithContext(ctx context.Context) VcsA return pulumi.ToOutputWithContext(ctx, i).(VcsAgentPoolOutput) } +func (i *VcsAgentPool) ToOutput(ctx context.Context) pulumix.Output[*VcsAgentPool] { + return pulumix.Output[*VcsAgentPool]{ + OutputState: i.ToVcsAgentPoolOutputWithContext(ctx).OutputState, + } +} + // VcsAgentPoolArrayInput is an input type that accepts VcsAgentPoolArray and VcsAgentPoolArrayOutput values. // You can construct a concrete instance of `VcsAgentPoolArrayInput` via: // @@ -170,6 +182,12 @@ func (i VcsAgentPoolArray) ToVcsAgentPoolArrayOutputWithContext(ctx context.Cont return pulumi.ToOutputWithContext(ctx, i).(VcsAgentPoolArrayOutput) } +func (i VcsAgentPoolArray) ToOutput(ctx context.Context) pulumix.Output[[]*VcsAgentPool] { + return pulumix.Output[[]*VcsAgentPool]{ + OutputState: i.ToVcsAgentPoolArrayOutputWithContext(ctx).OutputState, + } +} + // VcsAgentPoolMapInput is an input type that accepts VcsAgentPoolMap and VcsAgentPoolMapOutput values. // You can construct a concrete instance of `VcsAgentPoolMapInput` via: // @@ -195,6 +213,12 @@ func (i VcsAgentPoolMap) ToVcsAgentPoolMapOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(VcsAgentPoolMapOutput) } +func (i VcsAgentPoolMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VcsAgentPool] { + return pulumix.Output[map[string]*VcsAgentPool]{ + OutputState: i.ToVcsAgentPoolMapOutputWithContext(ctx).OutputState, + } +} + type VcsAgentPoolOutput struct{ *pulumi.OutputState } func (VcsAgentPoolOutput) ElementType() reflect.Type { @@ -209,6 +233,12 @@ func (o VcsAgentPoolOutput) ToVcsAgentPoolOutputWithContext(ctx context.Context) return o } +func (o VcsAgentPoolOutput) ToOutput(ctx context.Context) pulumix.Output[*VcsAgentPool] { + return pulumix.Output[*VcsAgentPool]{ + OutputState: o.OutputState, + } +} + // VCS agent pool configuration, encoded using base64 func (o VcsAgentPoolOutput) Config() pulumi.StringOutput { return o.ApplyT(func(v *VcsAgentPool) pulumi.StringOutput { return v.Config }).(pulumi.StringOutput) @@ -238,6 +268,12 @@ func (o VcsAgentPoolArrayOutput) ToVcsAgentPoolArrayOutputWithContext(ctx contex return o } +func (o VcsAgentPoolArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VcsAgentPool] { + return pulumix.Output[[]*VcsAgentPool]{ + OutputState: o.OutputState, + } +} + func (o VcsAgentPoolArrayOutput) Index(i pulumi.IntInput) VcsAgentPoolOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VcsAgentPool { return vs[0].([]*VcsAgentPool)[vs[1].(int)] @@ -258,6 +294,12 @@ func (o VcsAgentPoolMapOutput) ToVcsAgentPoolMapOutputWithContext(ctx context.Co return o } +func (o VcsAgentPoolMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VcsAgentPool] { + return pulumix.Output[map[string]*VcsAgentPool]{ + OutputState: o.OutputState, + } +} + func (o VcsAgentPoolMapOutput) MapIndex(k pulumi.StringInput) VcsAgentPoolOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VcsAgentPool { return vs[0].(map[string]*VcsAgentPool)[vs[1].(string)] diff --git a/sdk/go/spacelift/version.go b/sdk/go/spacelift/version.go new file mode 100644 index 0000000..5b34808 --- /dev/null +++ b/sdk/go/spacelift/version.go @@ -0,0 +1,301 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package spacelift + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" +) + +// `Version` allows to programmatically trigger a version creation in response to arbitrary changes in the keepers section. +type Version struct { + pulumi.CustomResourceState + + // The commit SHA for which to trigger a version. + CommitSha pulumi.StringPtrOutput `pulumi:"commitSha"` + // Arbitrary map of values that, when changed, will trigger recreation of the resource. + Keepers pulumi.MapOutput `pulumi:"keepers"` + // ID of the module on which the version creation is to be triggered. + ModuleId pulumi.StringOutput `pulumi:"moduleId"` + // A semantic version number to set for the triggered version, example: 0.11.2 + VersionNumber pulumi.StringPtrOutput `pulumi:"versionNumber"` +} + +// NewVersion registers a new resource with the given unique name, arguments, and options. +func NewVersion(ctx *pulumi.Context, + name string, args *VersionArgs, opts ...pulumi.ResourceOption) (*Version, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ModuleId == nil { + return nil, errors.New("invalid value for required argument 'ModuleId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Version + err := ctx.RegisterResource("spacelift:index/version:Version", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetVersion gets an existing Version resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetVersion(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *VersionState, opts ...pulumi.ResourceOption) (*Version, error) { + var resource Version + err := ctx.ReadResource("spacelift:index/version:Version", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Version resources. +type versionState struct { + // The commit SHA for which to trigger a version. + CommitSha *string `pulumi:"commitSha"` + // Arbitrary map of values that, when changed, will trigger recreation of the resource. + Keepers map[string]interface{} `pulumi:"keepers"` + // ID of the module on which the version creation is to be triggered. + ModuleId *string `pulumi:"moduleId"` + // A semantic version number to set for the triggered version, example: 0.11.2 + VersionNumber *string `pulumi:"versionNumber"` +} + +type VersionState struct { + // The commit SHA for which to trigger a version. + CommitSha pulumi.StringPtrInput + // Arbitrary map of values that, when changed, will trigger recreation of the resource. + Keepers pulumi.MapInput + // ID of the module on which the version creation is to be triggered. + ModuleId pulumi.StringPtrInput + // A semantic version number to set for the triggered version, example: 0.11.2 + VersionNumber pulumi.StringPtrInput +} + +func (VersionState) ElementType() reflect.Type { + return reflect.TypeOf((*versionState)(nil)).Elem() +} + +type versionArgs struct { + // The commit SHA for which to trigger a version. + CommitSha *string `pulumi:"commitSha"` + // Arbitrary map of values that, when changed, will trigger recreation of the resource. + Keepers map[string]interface{} `pulumi:"keepers"` + // ID of the module on which the version creation is to be triggered. + ModuleId string `pulumi:"moduleId"` + // A semantic version number to set for the triggered version, example: 0.11.2 + VersionNumber *string `pulumi:"versionNumber"` +} + +// The set of arguments for constructing a Version resource. +type VersionArgs struct { + // The commit SHA for which to trigger a version. + CommitSha pulumi.StringPtrInput + // Arbitrary map of values that, when changed, will trigger recreation of the resource. + Keepers pulumi.MapInput + // ID of the module on which the version creation is to be triggered. + ModuleId pulumi.StringInput + // A semantic version number to set for the triggered version, example: 0.11.2 + VersionNumber pulumi.StringPtrInput +} + +func (VersionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*versionArgs)(nil)).Elem() +} + +type VersionInput interface { + pulumi.Input + + ToVersionOutput() VersionOutput + ToVersionOutputWithContext(ctx context.Context) VersionOutput +} + +func (*Version) ElementType() reflect.Type { + return reflect.TypeOf((**Version)(nil)).Elem() +} + +func (i *Version) ToVersionOutput() VersionOutput { + return i.ToVersionOutputWithContext(context.Background()) +} + +func (i *Version) ToVersionOutputWithContext(ctx context.Context) VersionOutput { + return pulumi.ToOutputWithContext(ctx, i).(VersionOutput) +} + +func (i *Version) ToOutput(ctx context.Context) pulumix.Output[*Version] { + return pulumix.Output[*Version]{ + OutputState: i.ToVersionOutputWithContext(ctx).OutputState, + } +} + +// VersionArrayInput is an input type that accepts VersionArray and VersionArrayOutput values. +// You can construct a concrete instance of `VersionArrayInput` via: +// +// VersionArray{ VersionArgs{...} } +type VersionArrayInput interface { + pulumi.Input + + ToVersionArrayOutput() VersionArrayOutput + ToVersionArrayOutputWithContext(context.Context) VersionArrayOutput +} + +type VersionArray []VersionInput + +func (VersionArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Version)(nil)).Elem() +} + +func (i VersionArray) ToVersionArrayOutput() VersionArrayOutput { + return i.ToVersionArrayOutputWithContext(context.Background()) +} + +func (i VersionArray) ToVersionArrayOutputWithContext(ctx context.Context) VersionArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(VersionArrayOutput) +} + +func (i VersionArray) ToOutput(ctx context.Context) pulumix.Output[[]*Version] { + return pulumix.Output[[]*Version]{ + OutputState: i.ToVersionArrayOutputWithContext(ctx).OutputState, + } +} + +// VersionMapInput is an input type that accepts VersionMap and VersionMapOutput values. +// You can construct a concrete instance of `VersionMapInput` via: +// +// VersionMap{ "key": VersionArgs{...} } +type VersionMapInput interface { + pulumi.Input + + ToVersionMapOutput() VersionMapOutput + ToVersionMapOutputWithContext(context.Context) VersionMapOutput +} + +type VersionMap map[string]VersionInput + +func (VersionMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Version)(nil)).Elem() +} + +func (i VersionMap) ToVersionMapOutput() VersionMapOutput { + return i.ToVersionMapOutputWithContext(context.Background()) +} + +func (i VersionMap) ToVersionMapOutputWithContext(ctx context.Context) VersionMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(VersionMapOutput) +} + +func (i VersionMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Version] { + return pulumix.Output[map[string]*Version]{ + OutputState: i.ToVersionMapOutputWithContext(ctx).OutputState, + } +} + +type VersionOutput struct{ *pulumi.OutputState } + +func (VersionOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Version)(nil)).Elem() +} + +func (o VersionOutput) ToVersionOutput() VersionOutput { + return o +} + +func (o VersionOutput) ToVersionOutputWithContext(ctx context.Context) VersionOutput { + return o +} + +func (o VersionOutput) ToOutput(ctx context.Context) pulumix.Output[*Version] { + return pulumix.Output[*Version]{ + OutputState: o.OutputState, + } +} + +// The commit SHA for which to trigger a version. +func (o VersionOutput) CommitSha() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Version) pulumi.StringPtrOutput { return v.CommitSha }).(pulumi.StringPtrOutput) +} + +// Arbitrary map of values that, when changed, will trigger recreation of the resource. +func (o VersionOutput) Keepers() pulumi.MapOutput { + return o.ApplyT(func(v *Version) pulumi.MapOutput { return v.Keepers }).(pulumi.MapOutput) +} + +// ID of the module on which the version creation is to be triggered. +func (o VersionOutput) ModuleId() pulumi.StringOutput { + return o.ApplyT(func(v *Version) pulumi.StringOutput { return v.ModuleId }).(pulumi.StringOutput) +} + +// A semantic version number to set for the triggered version, example: 0.11.2 +func (o VersionOutput) VersionNumber() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Version) pulumi.StringPtrOutput { return v.VersionNumber }).(pulumi.StringPtrOutput) +} + +type VersionArrayOutput struct{ *pulumi.OutputState } + +func (VersionArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Version)(nil)).Elem() +} + +func (o VersionArrayOutput) ToVersionArrayOutput() VersionArrayOutput { + return o +} + +func (o VersionArrayOutput) ToVersionArrayOutputWithContext(ctx context.Context) VersionArrayOutput { + return o +} + +func (o VersionArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Version] { + return pulumix.Output[[]*Version]{ + OutputState: o.OutputState, + } +} + +func (o VersionArrayOutput) Index(i pulumi.IntInput) VersionOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Version { + return vs[0].([]*Version)[vs[1].(int)] + }).(VersionOutput) +} + +type VersionMapOutput struct{ *pulumi.OutputState } + +func (VersionMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Version)(nil)).Elem() +} + +func (o VersionMapOutput) ToVersionMapOutput() VersionMapOutput { + return o +} + +func (o VersionMapOutput) ToVersionMapOutputWithContext(ctx context.Context) VersionMapOutput { + return o +} + +func (o VersionMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Version] { + return pulumix.Output[map[string]*Version]{ + OutputState: o.OutputState, + } +} + +func (o VersionMapOutput) MapIndex(k pulumi.StringInput) VersionOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Version { + return vs[0].(map[string]*Version)[vs[1].(string)] + }).(VersionOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*VersionInput)(nil)).Elem(), &Version{}) + pulumi.RegisterInputType(reflect.TypeOf((*VersionArrayInput)(nil)).Elem(), VersionArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*VersionMapInput)(nil)).Elem(), VersionMap{}) + pulumi.RegisterOutputType(VersionOutput{}) + pulumi.RegisterOutputType(VersionArrayOutput{}) + pulumi.RegisterOutputType(VersionMapOutput{}) +} diff --git a/sdk/go/spacelift/webhook.go b/sdk/go/spacelift/webhook.go index f87e0aa..985589c 100644 --- a/sdk/go/spacelift/webhook.go +++ b/sdk/go/spacelift/webhook.go @@ -7,8 +7,10 @@ import ( "context" "reflect" - "github.com/pkg/errors" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `Webhook` represents a webhook endpoint to which Spacelift sends the POST request about run state changes. @@ -21,7 +23,7 @@ import ( // import ( // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // @@ -72,7 +74,14 @@ func NewWebhook(ctx *pulumi.Context, if args.Endpoint == nil { return nil, errors.New("invalid value for required argument 'Endpoint'") } - opts = pkgResourceDefaultOpts(opts) + if args.Secret != nil { + args.Secret = pulumi.ToSecret(args.Secret).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "secret", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) var resource Webhook err := ctx.RegisterResource("spacelift:index/webhook:Webhook", name, args, &resource, opts...) if err != nil { @@ -174,6 +183,12 @@ func (i *Webhook) ToWebhookOutputWithContext(ctx context.Context) WebhookOutput return pulumi.ToOutputWithContext(ctx, i).(WebhookOutput) } +func (i *Webhook) ToOutput(ctx context.Context) pulumix.Output[*Webhook] { + return pulumix.Output[*Webhook]{ + OutputState: i.ToWebhookOutputWithContext(ctx).OutputState, + } +} + // WebhookArrayInput is an input type that accepts WebhookArray and WebhookArrayOutput values. // You can construct a concrete instance of `WebhookArrayInput` via: // @@ -199,6 +214,12 @@ func (i WebhookArray) ToWebhookArrayOutputWithContext(ctx context.Context) Webho return pulumi.ToOutputWithContext(ctx, i).(WebhookArrayOutput) } +func (i WebhookArray) ToOutput(ctx context.Context) pulumix.Output[[]*Webhook] { + return pulumix.Output[[]*Webhook]{ + OutputState: i.ToWebhookArrayOutputWithContext(ctx).OutputState, + } +} + // WebhookMapInput is an input type that accepts WebhookMap and WebhookMapOutput values. // You can construct a concrete instance of `WebhookMapInput` via: // @@ -224,6 +245,12 @@ func (i WebhookMap) ToWebhookMapOutputWithContext(ctx context.Context) WebhookMa return pulumi.ToOutputWithContext(ctx, i).(WebhookMapOutput) } +func (i WebhookMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Webhook] { + return pulumix.Output[map[string]*Webhook]{ + OutputState: i.ToWebhookMapOutputWithContext(ctx).OutputState, + } +} + type WebhookOutput struct{ *pulumi.OutputState } func (WebhookOutput) ElementType() reflect.Type { @@ -238,6 +265,12 @@ func (o WebhookOutput) ToWebhookOutputWithContext(ctx context.Context) WebhookOu return o } +func (o WebhookOutput) ToOutput(ctx context.Context) pulumix.Output[*Webhook] { + return pulumix.Output[*Webhook]{ + OutputState: o.OutputState, + } +} + // enables or disables sending webhooks. Defaults to `true`. func (o WebhookOutput) Enabled() pulumi.BoolPtrOutput { return o.ApplyT(func(v *Webhook) pulumi.BoolPtrOutput { return v.Enabled }).(pulumi.BoolPtrOutput) @@ -277,6 +310,12 @@ func (o WebhookArrayOutput) ToWebhookArrayOutputWithContext(ctx context.Context) return o } +func (o WebhookArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*Webhook] { + return pulumix.Output[[]*Webhook]{ + OutputState: o.OutputState, + } +} + func (o WebhookArrayOutput) Index(i pulumi.IntInput) WebhookOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Webhook { return vs[0].([]*Webhook)[vs[1].(int)] @@ -297,6 +336,12 @@ func (o WebhookMapOutput) ToWebhookMapOutputWithContext(ctx context.Context) Web return o } +func (o WebhookMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*Webhook] { + return pulumix.Output[map[string]*Webhook]{ + OutputState: o.OutputState, + } +} + func (o WebhookMapOutput) MapIndex(k pulumi.StringInput) WebhookOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Webhook { return vs[0].(map[string]*Webhook)[vs[1].(string)] diff --git a/sdk/go/spacelift/webook.go b/sdk/go/spacelift/webook.go deleted file mode 100644 index de12a54..0000000 --- a/sdk/go/spacelift/webook.go +++ /dev/null @@ -1,308 +0,0 @@ -// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. -// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** - -package spacelift - -import ( - "context" - "reflect" - - "github.com/pkg/errors" - "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -) - -// `Webook` represents a webhook endpoint to which Spacelift sends the POST request about run state changes. -// -// ## Example Usage -// -// ```go -// package main -// -// import ( -// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" -// ) -// -// func main() { -// pulumi.Run(func(ctx *pulumi.Context) error { -// _, err := spacelift.NewWebook(ctx, "webhook", &spacelift.WebookArgs{ -// Endpoint: pulumi.String("https://example.com/webhooks"), -// StackId: pulumi.String("k8s-core"), -// }) -// if err != nil { -// return err -// } -// return nil -// }) -// } -// ``` -// -// ## Import -// -// ```sh -// $ pulumi import spacelift:index/webook:Webook webhook stack/$STACK_ID/$WEBHOOK_ID -// ``` -type Webook struct { - pulumi.CustomResourceState - - // enables or disables sending webhooks. Defaults to `true`. - Enabled pulumi.BoolPtrOutput `pulumi:"enabled"` - // endpoint to send the POST request to - Endpoint pulumi.StringOutput `pulumi:"endpoint"` - // ID of the module which triggers the webhooks - ModuleId pulumi.StringPtrOutput `pulumi:"moduleId"` - // secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. - Secret pulumi.StringPtrOutput `pulumi:"secret"` - // ID of the stack which triggers the webhooks - StackId pulumi.StringPtrOutput `pulumi:"stackId"` -} - -// NewWebook registers a new resource with the given unique name, arguments, and options. -func NewWebook(ctx *pulumi.Context, - name string, args *WebookArgs, opts ...pulumi.ResourceOption) (*Webook, error) { - if args == nil { - return nil, errors.New("missing one or more required arguments") - } - - if args.Endpoint == nil { - return nil, errors.New("invalid value for required argument 'Endpoint'") - } - opts = pkgResourceDefaultOpts(opts) - var resource Webook - err := ctx.RegisterResource("spacelift:index/webook:Webook", name, args, &resource, opts...) - if err != nil { - return nil, err - } - return &resource, nil -} - -// GetWebook gets an existing Webook resource's state with the given name, ID, and optional -// state properties that are used to uniquely qualify the lookup (nil if not required). -func GetWebook(ctx *pulumi.Context, - name string, id pulumi.IDInput, state *WebookState, opts ...pulumi.ResourceOption) (*Webook, error) { - var resource Webook - err := ctx.ReadResource("spacelift:index/webook:Webook", name, id, state, &resource, opts...) - if err != nil { - return nil, err - } - return &resource, nil -} - -// Input properties used for looking up and filtering Webook resources. -type webookState struct { - // enables or disables sending webhooks. Defaults to `true`. - Enabled *bool `pulumi:"enabled"` - // endpoint to send the POST request to - Endpoint *string `pulumi:"endpoint"` - // ID of the module which triggers the webhooks - ModuleId *string `pulumi:"moduleId"` - // secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. - Secret *string `pulumi:"secret"` - // ID of the stack which triggers the webhooks - StackId *string `pulumi:"stackId"` -} - -type WebookState struct { - // enables or disables sending webhooks. Defaults to `true`. - Enabled pulumi.BoolPtrInput - // endpoint to send the POST request to - Endpoint pulumi.StringPtrInput - // ID of the module which triggers the webhooks - ModuleId pulumi.StringPtrInput - // secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. - Secret pulumi.StringPtrInput - // ID of the stack which triggers the webhooks - StackId pulumi.StringPtrInput -} - -func (WebookState) ElementType() reflect.Type { - return reflect.TypeOf((*webookState)(nil)).Elem() -} - -type webookArgs struct { - // enables or disables sending webhooks. Defaults to `true`. - Enabled *bool `pulumi:"enabled"` - // endpoint to send the POST request to - Endpoint string `pulumi:"endpoint"` - // ID of the module which triggers the webhooks - ModuleId *string `pulumi:"moduleId"` - // secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. - Secret *string `pulumi:"secret"` - // ID of the stack which triggers the webhooks - StackId *string `pulumi:"stackId"` -} - -// The set of arguments for constructing a Webook resource. -type WebookArgs struct { - // enables or disables sending webhooks. Defaults to `true`. - Enabled pulumi.BoolPtrInput - // endpoint to send the POST request to - Endpoint pulumi.StringInput - // ID of the module which triggers the webhooks - ModuleId pulumi.StringPtrInput - // secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. - Secret pulumi.StringPtrInput - // ID of the stack which triggers the webhooks - StackId pulumi.StringPtrInput -} - -func (WebookArgs) ElementType() reflect.Type { - return reflect.TypeOf((*webookArgs)(nil)).Elem() -} - -type WebookInput interface { - pulumi.Input - - ToWebookOutput() WebookOutput - ToWebookOutputWithContext(ctx context.Context) WebookOutput -} - -func (*Webook) ElementType() reflect.Type { - return reflect.TypeOf((**Webook)(nil)).Elem() -} - -func (i *Webook) ToWebookOutput() WebookOutput { - return i.ToWebookOutputWithContext(context.Background()) -} - -func (i *Webook) ToWebookOutputWithContext(ctx context.Context) WebookOutput { - return pulumi.ToOutputWithContext(ctx, i).(WebookOutput) -} - -// WebookArrayInput is an input type that accepts WebookArray and WebookArrayOutput values. -// You can construct a concrete instance of `WebookArrayInput` via: -// -// WebookArray{ WebookArgs{...} } -type WebookArrayInput interface { - pulumi.Input - - ToWebookArrayOutput() WebookArrayOutput - ToWebookArrayOutputWithContext(context.Context) WebookArrayOutput -} - -type WebookArray []WebookInput - -func (WebookArray) ElementType() reflect.Type { - return reflect.TypeOf((*[]*Webook)(nil)).Elem() -} - -func (i WebookArray) ToWebookArrayOutput() WebookArrayOutput { - return i.ToWebookArrayOutputWithContext(context.Background()) -} - -func (i WebookArray) ToWebookArrayOutputWithContext(ctx context.Context) WebookArrayOutput { - return pulumi.ToOutputWithContext(ctx, i).(WebookArrayOutput) -} - -// WebookMapInput is an input type that accepts WebookMap and WebookMapOutput values. -// You can construct a concrete instance of `WebookMapInput` via: -// -// WebookMap{ "key": WebookArgs{...} } -type WebookMapInput interface { - pulumi.Input - - ToWebookMapOutput() WebookMapOutput - ToWebookMapOutputWithContext(context.Context) WebookMapOutput -} - -type WebookMap map[string]WebookInput - -func (WebookMap) ElementType() reflect.Type { - return reflect.TypeOf((*map[string]*Webook)(nil)).Elem() -} - -func (i WebookMap) ToWebookMapOutput() WebookMapOutput { - return i.ToWebookMapOutputWithContext(context.Background()) -} - -func (i WebookMap) ToWebookMapOutputWithContext(ctx context.Context) WebookMapOutput { - return pulumi.ToOutputWithContext(ctx, i).(WebookMapOutput) -} - -type WebookOutput struct{ *pulumi.OutputState } - -func (WebookOutput) ElementType() reflect.Type { - return reflect.TypeOf((**Webook)(nil)).Elem() -} - -func (o WebookOutput) ToWebookOutput() WebookOutput { - return o -} - -func (o WebookOutput) ToWebookOutputWithContext(ctx context.Context) WebookOutput { - return o -} - -// enables or disables sending webhooks. Defaults to `true`. -func (o WebookOutput) Enabled() pulumi.BoolPtrOutput { - return o.ApplyT(func(v *Webook) pulumi.BoolPtrOutput { return v.Enabled }).(pulumi.BoolPtrOutput) -} - -// endpoint to send the POST request to -func (o WebookOutput) Endpoint() pulumi.StringOutput { - return o.ApplyT(func(v *Webook) pulumi.StringOutput { return v.Endpoint }).(pulumi.StringOutput) -} - -// ID of the module which triggers the webhooks -func (o WebookOutput) ModuleId() pulumi.StringPtrOutput { - return o.ApplyT(func(v *Webook) pulumi.StringPtrOutput { return v.ModuleId }).(pulumi.StringPtrOutput) -} - -// secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. -func (o WebookOutput) Secret() pulumi.StringPtrOutput { - return o.ApplyT(func(v *Webook) pulumi.StringPtrOutput { return v.Secret }).(pulumi.StringPtrOutput) -} - -// ID of the stack which triggers the webhooks -func (o WebookOutput) StackId() pulumi.StringPtrOutput { - return o.ApplyT(func(v *Webook) pulumi.StringPtrOutput { return v.StackId }).(pulumi.StringPtrOutput) -} - -type WebookArrayOutput struct{ *pulumi.OutputState } - -func (WebookArrayOutput) ElementType() reflect.Type { - return reflect.TypeOf((*[]*Webook)(nil)).Elem() -} - -func (o WebookArrayOutput) ToWebookArrayOutput() WebookArrayOutput { - return o -} - -func (o WebookArrayOutput) ToWebookArrayOutputWithContext(ctx context.Context) WebookArrayOutput { - return o -} - -func (o WebookArrayOutput) Index(i pulumi.IntInput) WebookOutput { - return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Webook { - return vs[0].([]*Webook)[vs[1].(int)] - }).(WebookOutput) -} - -type WebookMapOutput struct{ *pulumi.OutputState } - -func (WebookMapOutput) ElementType() reflect.Type { - return reflect.TypeOf((*map[string]*Webook)(nil)).Elem() -} - -func (o WebookMapOutput) ToWebookMapOutput() WebookMapOutput { - return o -} - -func (o WebookMapOutput) ToWebookMapOutputWithContext(ctx context.Context) WebookMapOutput { - return o -} - -func (o WebookMapOutput) MapIndex(k pulumi.StringInput) WebookOutput { - return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Webook { - return vs[0].(map[string]*Webook)[vs[1].(string)] - }).(WebookOutput) -} - -func init() { - pulumi.RegisterInputType(reflect.TypeOf((*WebookInput)(nil)).Elem(), &Webook{}) - pulumi.RegisterInputType(reflect.TypeOf((*WebookArrayInput)(nil)).Elem(), WebookArray{}) - pulumi.RegisterInputType(reflect.TypeOf((*WebookMapInput)(nil)).Elem(), WebookMap{}) - pulumi.RegisterOutputType(WebookOutput{}) - pulumi.RegisterOutputType(WebookArrayOutput{}) - pulumi.RegisterOutputType(WebookMapOutput{}) -} diff --git a/sdk/go/spacelift/workerPool.go b/sdk/go/spacelift/workerPool.go index 510e8c5..7ccb607 100644 --- a/sdk/go/spacelift/workerPool.go +++ b/sdk/go/spacelift/workerPool.go @@ -8,6 +8,8 @@ import ( "reflect" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumix" + "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift/internal" ) // `WorkerPool` represents a worker pool assigned to the Spacelift account. @@ -20,15 +22,15 @@ import ( // import ( // // "encoding/base64" -// "io/ioutil" +// "os" // // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" -// "github.com/spacelift-io/pulumi-spacelift/sdk/go/spacelift" +// "github.com/spacelift-io/pulumi-spacelift/sdk/v2/go/spacelift" // // ) // // func filebase64OrPanic(path string) pulumi.StringPtrInput { -// if fileData, err := ioutil.ReadFile(path); err == nil { +// if fileData, err := os.ReadFile(path); err == nil { // return pulumi.String(base64.StdEncoding.EncodeToString(fileData[:])) // } else { // panic(err.Error()) @@ -82,7 +84,16 @@ func NewWorkerPool(ctx *pulumi.Context, args = &WorkerPoolArgs{} } - opts = pkgResourceDefaultOpts(opts) + if args.Csr != nil { + args.Csr = pulumi.ToSecret(args.Csr).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "config", + "csr", + "privateKey", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) var resource WorkerPool err := ctx.RegisterResource("spacelift:index/workerPool:WorkerPool", name, args, &resource, opts...) if err != nil { @@ -188,6 +199,12 @@ func (i *WorkerPool) ToWorkerPoolOutputWithContext(ctx context.Context) WorkerPo return pulumi.ToOutputWithContext(ctx, i).(WorkerPoolOutput) } +func (i *WorkerPool) ToOutput(ctx context.Context) pulumix.Output[*WorkerPool] { + return pulumix.Output[*WorkerPool]{ + OutputState: i.ToWorkerPoolOutputWithContext(ctx).OutputState, + } +} + // WorkerPoolArrayInput is an input type that accepts WorkerPoolArray and WorkerPoolArrayOutput values. // You can construct a concrete instance of `WorkerPoolArrayInput` via: // @@ -213,6 +230,12 @@ func (i WorkerPoolArray) ToWorkerPoolArrayOutputWithContext(ctx context.Context) return pulumi.ToOutputWithContext(ctx, i).(WorkerPoolArrayOutput) } +func (i WorkerPoolArray) ToOutput(ctx context.Context) pulumix.Output[[]*WorkerPool] { + return pulumix.Output[[]*WorkerPool]{ + OutputState: i.ToWorkerPoolArrayOutputWithContext(ctx).OutputState, + } +} + // WorkerPoolMapInput is an input type that accepts WorkerPoolMap and WorkerPoolMapOutput values. // You can construct a concrete instance of `WorkerPoolMapInput` via: // @@ -238,6 +261,12 @@ func (i WorkerPoolMap) ToWorkerPoolMapOutputWithContext(ctx context.Context) Wor return pulumi.ToOutputWithContext(ctx, i).(WorkerPoolMapOutput) } +func (i WorkerPoolMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*WorkerPool] { + return pulumix.Output[map[string]*WorkerPool]{ + OutputState: i.ToWorkerPoolMapOutputWithContext(ctx).OutputState, + } +} + type WorkerPoolOutput struct{ *pulumi.OutputState } func (WorkerPoolOutput) ElementType() reflect.Type { @@ -252,6 +281,12 @@ func (o WorkerPoolOutput) ToWorkerPoolOutputWithContext(ctx context.Context) Wor return o } +func (o WorkerPoolOutput) ToOutput(ctx context.Context) pulumix.Output[*WorkerPool] { + return pulumix.Output[*WorkerPool]{ + OutputState: o.OutputState, + } +} + // credentials necessary to connect WorkerPool's workers to the control plane func (o WorkerPoolOutput) Config() pulumi.StringOutput { return o.ApplyT(func(v *WorkerPool) pulumi.StringOutput { return v.Config }).(pulumi.StringOutput) @@ -300,6 +335,12 @@ func (o WorkerPoolArrayOutput) ToWorkerPoolArrayOutputWithContext(ctx context.Co return o } +func (o WorkerPoolArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*WorkerPool] { + return pulumix.Output[[]*WorkerPool]{ + OutputState: o.OutputState, + } +} + func (o WorkerPoolArrayOutput) Index(i pulumi.IntInput) WorkerPoolOutput { return pulumi.All(o, i).ApplyT(func(vs []interface{}) *WorkerPool { return vs[0].([]*WorkerPool)[vs[1].(int)] @@ -320,6 +361,12 @@ func (o WorkerPoolMapOutput) ToWorkerPoolMapOutputWithContext(ctx context.Contex return o } +func (o WorkerPoolMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*WorkerPool] { + return pulumix.Output[map[string]*WorkerPool]{ + OutputState: o.OutputState, + } +} + func (o WorkerPoolMapOutput) MapIndex(k pulumi.StringInput) WorkerPoolOutput { return pulumi.All(o, k).ApplyT(func(vs []interface{}) *WorkerPool { return vs[0].(map[string]*WorkerPool)[vs[1].(string)] diff --git a/sdk/nodejs/awsIntegration.ts b/sdk/nodejs/awsIntegration.ts index a1f3c4f..f75b7d7 100644 --- a/sdk/nodejs/awsIntegration.ts +++ b/sdk/nodejs/awsIntegration.ts @@ -7,7 +7,7 @@ import * as utilities from "./utilities"; /** * `spacelift.AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. * - * Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-$suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + * Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@$suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. * * ## Import * diff --git a/sdk/nodejs/azureIntegration.ts b/sdk/nodejs/azureIntegration.ts index 90e9cac..c73ef6e 100644 --- a/sdk/nodejs/azureIntegration.ts +++ b/sdk/nodejs/azureIntegration.ts @@ -11,7 +11,7 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * * const example = new spacelift.AzureIntegration("example", { * defaultSubscriptionId: "default-subscription-id", diff --git a/sdk/nodejs/blueprint.ts b/sdk/nodejs/blueprint.ts new file mode 100644 index 0000000..eab8be1 --- /dev/null +++ b/sdk/nodejs/blueprint.ts @@ -0,0 +1,157 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +export class Blueprint extends pulumi.CustomResource { + /** + * Get an existing Blueprint resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: BlueprintState, opts?: pulumi.CustomResourceOptions): Blueprint { + return new Blueprint(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/blueprint:Blueprint'; + + /** + * Returns true if the given object is an instance of Blueprint. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is Blueprint { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === Blueprint.__pulumiType; + } + + /** + * Description of the blueprint + */ + public readonly description!: pulumi.Output; + /** + * Labels of the blueprint + */ + public readonly labels!: pulumi.Output; + /** + * Name of the blueprint + */ + public readonly name!: pulumi.Output; + /** + * ID of the space the blueprint is in + */ + public readonly space!: pulumi.Output; + /** + * State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + */ + public readonly state!: pulumi.Output; + /** + * Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + */ + public readonly template!: pulumi.Output; + + /** + * Create a Blueprint resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: BlueprintArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: BlueprintArgs | BlueprintState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as BlueprintState | undefined; + resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["space"] = state ? state.space : undefined; + resourceInputs["state"] = state ? state.state : undefined; + resourceInputs["template"] = state ? state.template : undefined; + } else { + const args = argsOrState as BlueprintArgs | undefined; + if ((!args || args.space === undefined) && !opts.urn) { + throw new Error("Missing required property 'space'"); + } + if ((!args || args.state === undefined) && !opts.urn) { + throw new Error("Missing required property 'state'"); + } + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["space"] = args ? args.space : undefined; + resourceInputs["state"] = args ? args.state : undefined; + resourceInputs["template"] = args ? args.template : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Blueprint.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering Blueprint resources. + */ +export interface BlueprintState { + /** + * Description of the blueprint + */ + description?: pulumi.Input; + /** + * Labels of the blueprint + */ + labels?: pulumi.Input[]>; + /** + * Name of the blueprint + */ + name?: pulumi.Input; + /** + * ID of the space the blueprint is in + */ + space?: pulumi.Input; + /** + * State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + */ + state?: pulumi.Input; + /** + * Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + */ + template?: pulumi.Input; +} + +/** + * The set of arguments for constructing a Blueprint resource. + */ +export interface BlueprintArgs { + /** + * Description of the blueprint + */ + description?: pulumi.Input; + /** + * Labels of the blueprint + */ + labels?: pulumi.Input[]>; + /** + * Name of the blueprint + */ + name?: pulumi.Input; + /** + * ID of the space the blueprint is in + */ + space: pulumi.Input; + /** + * State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + */ + state: pulumi.Input; + /** + * Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + */ + template?: pulumi.Input; +} diff --git a/sdk/nodejs/context.ts b/sdk/nodejs/context.ts index 7efefd8..fd7cfea 100644 --- a/sdk/nodejs/context.ts +++ b/sdk/nodejs/context.ts @@ -11,11 +11,9 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * - * const prod_k8s_ie = new spacelift.Context("prod-k8s-ie", { - * description: "Configuration details for the compute cluster in 🇮🇪", - * }); + * const prod_k8s_ie = new spacelift.Context("prod-k8s-ie", {description: "Configuration details for the compute cluster in 🇮🇪"}); * ``` * * ## Import diff --git a/sdk/nodejs/contextAttachment.ts b/sdk/nodejs/contextAttachment.ts index 2e74ee7..86e1363 100644 --- a/sdk/nodejs/contextAttachment.ts +++ b/sdk/nodejs/contextAttachment.ts @@ -11,7 +11,7 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * * // For a module * const attachment = new spacelift.ContextAttachment("attachment", { diff --git a/sdk/nodejs/driftDetection.ts b/sdk/nodejs/driftDetection.ts index fa25aec..7dc8b78 100644 --- a/sdk/nodejs/driftDetection.ts +++ b/sdk/nodejs/driftDetection.ts @@ -63,6 +63,10 @@ export class DriftDetection extends pulumi.CustomResource { return obj['__pulumiType'] === DriftDetection.__pulumiType; } + /** + * Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + */ + public readonly ignoreState!: pulumi.Output; /** * Whether a tracked run should be triggered when drift is detected. */ @@ -93,6 +97,7 @@ export class DriftDetection extends pulumi.CustomResource { opts = opts || {}; if (opts.id) { const state = argsOrState as DriftDetectionState | undefined; + resourceInputs["ignoreState"] = state ? state.ignoreState : undefined; resourceInputs["reconcile"] = state ? state.reconcile : undefined; resourceInputs["schedules"] = state ? state.schedules : undefined; resourceInputs["stackId"] = state ? state.stackId : undefined; @@ -105,6 +110,7 @@ export class DriftDetection extends pulumi.CustomResource { if ((!args || args.stackId === undefined) && !opts.urn) { throw new Error("Missing required property 'stackId'"); } + resourceInputs["ignoreState"] = args ? args.ignoreState : undefined; resourceInputs["reconcile"] = args ? args.reconcile : undefined; resourceInputs["schedules"] = args ? args.schedules : undefined; resourceInputs["stackId"] = args ? args.stackId : undefined; @@ -119,6 +125,10 @@ export class DriftDetection extends pulumi.CustomResource { * Input properties used for looking up and filtering DriftDetection resources. */ export interface DriftDetectionState { + /** + * Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + */ + ignoreState?: pulumi.Input; /** * Whether a tracked run should be triggered when drift is detected. */ @@ -141,6 +151,10 @@ export interface DriftDetectionState { * The set of arguments for constructing a DriftDetection resource. */ export interface DriftDetectionArgs { + /** + * Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + */ + ignoreState?: pulumi.Input; /** * Whether a tracked run should be triggered when drift is detected. */ diff --git a/sdk/nodejs/environmentVariable.ts b/sdk/nodejs/environmentVariable.ts index 7b469da..5255e42 100644 --- a/sdk/nodejs/environmentVariable.ts +++ b/sdk/nodejs/environmentVariable.ts @@ -11,7 +11,7 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * * // For a context * const ireland_kubeconfig = new spacelift.EnvironmentVariable("ireland-kubeconfig", { @@ -96,11 +96,11 @@ export class EnvironmentVariable extends pulumi.CustomResource { */ public readonly stackId!: pulumi.Output; /** - * Value of the environment variable + * Value of the environment variable. Defaults to an empty string. */ - public readonly value!: pulumi.Output; + public readonly value!: pulumi.Output; /** - * Indicates whether the value can be read back outside a Run. Defaults to `true`. + * Indicates whether the value is secret or not. Defaults to `true`. */ public readonly writeOnly!: pulumi.Output; @@ -111,7 +111,7 @@ export class EnvironmentVariable extends pulumi.CustomResource { * @param args The arguments to use to populate this resource's properties. * @param opts A bag of options that control this resource's behavior. */ - constructor(name: string, args: EnvironmentVariableArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, args?: EnvironmentVariableArgs, opts?: pulumi.CustomResourceOptions) constructor(name: string, argsOrState?: EnvironmentVariableArgs | EnvironmentVariableState, opts?: pulumi.CustomResourceOptions) { let resourceInputs: pulumi.Inputs = {}; opts = opts || {}; @@ -126,18 +126,17 @@ export class EnvironmentVariable extends pulumi.CustomResource { resourceInputs["writeOnly"] = state ? state.writeOnly : undefined; } else { const args = argsOrState as EnvironmentVariableArgs | undefined; - if ((!args || args.value === undefined) && !opts.urn) { - throw new Error("Missing required property 'value'"); - } resourceInputs["contextId"] = args ? args.contextId : undefined; resourceInputs["moduleId"] = args ? args.moduleId : undefined; resourceInputs["name"] = args ? args.name : undefined; resourceInputs["stackId"] = args ? args.stackId : undefined; - resourceInputs["value"] = args ? args.value : undefined; + resourceInputs["value"] = args?.value ? pulumi.secret(args.value) : undefined; resourceInputs["writeOnly"] = args ? args.writeOnly : undefined; resourceInputs["checksum"] = undefined /*out*/; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["value"] }; + opts = pulumi.mergeOptions(opts, secretOpts); super(EnvironmentVariable.__pulumiType, name, resourceInputs, opts); } } @@ -167,11 +166,11 @@ export interface EnvironmentVariableState { */ stackId?: pulumi.Input; /** - * Value of the environment variable + * Value of the environment variable. Defaults to an empty string. */ value?: pulumi.Input; /** - * Indicates whether the value can be read back outside a Run. Defaults to `true`. + * Indicates whether the value is secret or not. Defaults to `true`. */ writeOnly?: pulumi.Input; } @@ -197,11 +196,11 @@ export interface EnvironmentVariableArgs { */ stackId?: pulumi.Input; /** - * Value of the environment variable + * Value of the environment variable. Defaults to an empty string. */ - value: pulumi.Input; + value?: pulumi.Input; /** - * Indicates whether the value can be read back outside a Run. Defaults to `true`. + * Indicates whether the value is secret or not. Defaults to `true`. */ writeOnly?: pulumi.Input; } diff --git a/sdk/nodejs/gcpServiceAccount.ts b/sdk/nodejs/gcpServiceAccount.ts index 16ce1a1..66ca5e0 100644 --- a/sdk/nodejs/gcpServiceAccount.ts +++ b/sdk/nodejs/gcpServiceAccount.ts @@ -9,7 +9,7 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as gcp from "@pulumi/gcp"; + * import * as google from "@pulumi/google"; * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * * const k8s_coreStack = new spacelift.Stack("k8s-coreStack", { @@ -24,14 +24,15 @@ import * as utilities from "./utilities"; * "https://www.googleapis.com/auth/devstorage.full_control", * ], * }); - * const k8s_coreProject = new gcp.organizations.Project("k8s-coreProject", { + * const k8s_coregoogle_project = new google.index.Google_project("k8s-coregoogle_project", { + * name: "Kubernetes code", * projectId: "unicorn-k8s-core", * orgId: _var.gcp_organization_id, * }); - * const k8s_coreIAMMember = new gcp.projects.IAMMember("k8s-coreIAMMember", { - * project: k8s_coreProject.id, + * const k8s_coregoogle_project_iam_member = new google.index.Google_project_iam_member("k8s-coregoogle_project_iam_member", { + * project: k8s_coregoogle_project.id, * role: "roles/owner", - * member: pulumi.interpolate`serviceAccount:${k8s_coreGcpServiceAccount.serviceAccountEmail}`, + * member: `serviceAccount:${k8s_coreGcpServiceAccount.serviceAccountEmail}`, * }); * ``` * diff --git a/sdk/nodejs/getAccount.ts b/sdk/nodejs/getAccount.ts index 3d7e2b4..242eae8 100644 --- a/sdk/nodejs/getAccount.ts +++ b/sdk/nodejs/getAccount.ts @@ -13,15 +13,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const thisAccount = pulumi.output(spacelift.getAccount()); + * const this = spacelift.getAccount({}); * ``` */ export function getAccount(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getAccount:getAccount", { }, opts); } @@ -47,3 +44,18 @@ export interface GetAccountResult { */ readonly tier: string; } +/** + * `spacelift.getAccount` represents the currently used Spacelift **account** + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const this = spacelift.getAccount({}); + * ``` + */ +export function getAccountOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getAccount(opts)) +} diff --git a/sdk/nodejs/getAwsIntegration.ts b/sdk/nodejs/getAwsIntegration.ts index 7bd28f1..c9d8c65 100644 --- a/sdk/nodejs/getAwsIntegration.ts +++ b/sdk/nodejs/getAwsIntegration.ts @@ -7,7 +7,7 @@ import * as utilities from "./utilities"; /** * `spacelift.AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. * - * Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + * Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. * * ## Example Usage * @@ -15,19 +15,15 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // Lookup an integration by its name: - * const example = pulumi.output(spacelift.getAwsIntegration({ + * const example = spacelift.getAwsIntegration({ * name: "Production", - * })); + * }); * ``` */ export function getAwsIntegration(args?: GetAwsIntegrationArgs, opts?: pulumi.InvokeOptions): Promise { args = args || {}; - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getAwsIntegration:getAwsIntegration", { "integrationId": args.integrationId, "name": args.name, @@ -86,9 +82,24 @@ export interface GetAwsIntegrationResult { */ readonly spaceId: string; } - +/** + * `spacelift.AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. + * + * Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const example = spacelift.getAwsIntegration({ + * name: "Production", + * }); + * ``` + */ export function getAwsIntegrationOutput(args?: GetAwsIntegrationOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getAwsIntegration(a, opts)) + return pulumi.output(args).apply((a: any) => getAwsIntegration(a, opts)) } /** diff --git a/sdk/nodejs/getAwsIntegrationAttachment.ts b/sdk/nodejs/getAwsIntegrationAttachment.ts index 7f87788..28d0636 100644 --- a/sdk/nodejs/getAwsIntegrationAttachment.ts +++ b/sdk/nodejs/getAwsIntegrationAttachment.ts @@ -8,11 +8,8 @@ import * as utilities from "./utilities"; * `spacelift.AwsIntegrationAttachment` represents the attachment between a reusable AWS integration and a single stack or module. */ export function getAwsIntegrationAttachment(args: GetAwsIntegrationAttachmentArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getAwsIntegrationAttachment:getAwsIntegrationAttachment", { "integrationId": args.integrationId, "moduleId": args.moduleId, @@ -71,9 +68,11 @@ export interface GetAwsIntegrationAttachmentResult { */ readonly write: boolean; } - +/** + * `spacelift.AwsIntegrationAttachment` represents the attachment between a reusable AWS integration and a single stack or module. + */ export function getAwsIntegrationAttachmentOutput(args: GetAwsIntegrationAttachmentOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getAwsIntegrationAttachment(a, opts)) + return pulumi.output(args).apply((a: any) => getAwsIntegrationAttachment(a, opts)) } /** diff --git a/sdk/nodejs/getAwsIntegrationAttachmentExternalId.ts b/sdk/nodejs/getAwsIntegrationAttachmentExternalId.ts index 2de8b98..e025718 100644 --- a/sdk/nodejs/getAwsIntegrationAttachmentExternalId.ts +++ b/sdk/nodejs/getAwsIntegrationAttachmentExternalId.ts @@ -28,11 +28,8 @@ import * as utilities from "./utilities"; * ``` */ export function getAwsIntegrationAttachmentExternalId(args: GetAwsIntegrationAttachmentExternalIdArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getAwsIntegrationAttachmentExternalId:getAwsIntegrationAttachmentExternalId", { "integrationId": args.integrationId, "moduleId": args.moduleId, @@ -105,9 +102,31 @@ export interface GetAwsIntegrationAttachmentExternalIdResult { */ readonly write?: boolean; } - +/** + * `spacelift.getAwsIntegrationAttachmentExternalId` is used to generate the external ID that would be used for role assumption when an AWS integration is attached to a stack or module. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const myStack = spacelift.getAwsIntegrationAttachmentExternalId({ + * integrationId: spacelift_aws_integration["this"].id, + * stackId: "my-stack-id", + * read: true, + * write: true, + * }); + * const myModule = spacelift.getAwsIntegrationAttachmentExternalId({ + * integrationId: spacelift_aws_integration["this"].id, + * moduleId: "my-module-id", + * read: true, + * write: true, + * }); + * ``` + */ export function getAwsIntegrationAttachmentExternalIdOutput(args: GetAwsIntegrationAttachmentExternalIdOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getAwsIntegrationAttachmentExternalId(a, opts)) + return pulumi.output(args).apply((a: any) => getAwsIntegrationAttachmentExternalId(a, opts)) } /** diff --git a/sdk/nodejs/getAwsIntegrations.ts b/sdk/nodejs/getAwsIntegrations.ts new file mode 100644 index 0000000..68d98b1 --- /dev/null +++ b/sdk/nodejs/getAwsIntegrations.ts @@ -0,0 +1,34 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * `spacelift.getAwsIntegrations` represents a list of all the AWS integrations in the Spacelift account visible to the API user. + */ +export function getAwsIntegrations(opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getAwsIntegrations:getAwsIntegrations", { + }, opts); +} + +/** + * A collection of values returned by getAwsIntegrations. + */ +export interface GetAwsIntegrationsResult { + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + readonly integrations: outputs.GetAwsIntegrationsIntegration[]; +} +/** + * `spacelift.getAwsIntegrations` represents a list of all the AWS integrations in the Spacelift account visible to the API user. + */ +export function getAwsIntegrationsOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getAwsIntegrations(opts)) +} diff --git a/sdk/nodejs/getAwsRole.ts b/sdk/nodejs/getAwsRole.ts index ab85db4..19feab9 100644 --- a/sdk/nodejs/getAwsRole.ts +++ b/sdk/nodejs/getAwsRole.ts @@ -17,23 +17,18 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // With a module - * const k8s_module = pulumi.output(spacelift.getAwsRole({ + * const k8s-module = spacelift.getAwsRole({ * moduleId: "k8s-module", - * })); - * // With a stack - * const k8s_core = pulumi.output(spacelift.getAwsRole({ + * }); + * const k8s-core = spacelift.getAwsRole({ * stackId: "k8s-core", - * })); + * }); * ``` */ export function getAwsRole(args?: GetAwsRoleArgs, opts?: pulumi.InvokeOptions): Promise { args = args || {}; - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getAwsRole:getAwsRole", { "moduleId": args.moduleId, "stackId": args.stackId, @@ -87,9 +82,29 @@ export interface GetAwsRoleResult { */ readonly stackId?: string; } - +/** + * `spacelift.AwsRole` represents [cross-account IAM role delegation](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) between the Spacelift worker and an individual stack or module. If this is set, Spacelift will use AWS STS to assume the supplied IAM role and put its temporary credentials in the runtime environment. + * + * If you use private workers, you can also assume IAM role on the worker side using your own AWS credentials (e.g. from EC2 instance profile). + * + * Note: when assuming credentials for **shared worker**, Spacelift will use `$accountName@$stackID` or `$accountName@$moduleID` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole). + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const k8s-module = spacelift.getAwsRole({ + * moduleId: "k8s-module", + * }); + * const k8s-core = spacelift.getAwsRole({ + * stackId: "k8s-core", + * }); + * ``` + */ export function getAwsRoleOutput(args?: GetAwsRoleOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getAwsRole(a, opts)) + return pulumi.output(args).apply((a: any) => getAwsRole(a, opts)) } /** diff --git a/sdk/nodejs/getAzureDevopsIntegration.ts b/sdk/nodejs/getAzureDevopsIntegration.ts index b2ab3bd..14a43a9 100644 --- a/sdk/nodejs/getAzureDevopsIntegration.ts +++ b/sdk/nodejs/getAzureDevopsIntegration.ts @@ -13,15 +13,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const azureDevopsIntegration = pulumi.output(spacelift.getAzureDevopsIntegration()); + * const azureDevopsIntegration = spacelift.getAzureDevopsIntegration({}); * ``` */ export function getAzureDevopsIntegration(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getAzureDevopsIntegration:getAzureDevopsIntegration", { }, opts); } @@ -43,3 +40,18 @@ export interface GetAzureDevopsIntegrationResult { */ readonly webhookPassword: string; } +/** + * `spacelift.getAzureDevopsIntegration` returns details about Azure DevOps integration + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const azureDevopsIntegration = spacelift.getAzureDevopsIntegration({}); + * ``` + */ +export function getAzureDevopsIntegrationOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getAzureDevopsIntegration(opts)) +} diff --git a/sdk/nodejs/getAzureIntegration.ts b/sdk/nodejs/getAzureIntegration.ts index 5d55d45..347419f 100644 --- a/sdk/nodejs/getAzureIntegration.ts +++ b/sdk/nodejs/getAzureIntegration.ts @@ -13,19 +13,15 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // Lookup an integration by its name: - * const example = pulumi.output(spacelift.getAzureIntegration({ + * const example = spacelift.getAzureIntegration({ * name: "Production", - * })); + * }); * ``` */ export function getAzureIntegration(args?: GetAzureIntegrationArgs, opts?: pulumi.InvokeOptions): Promise { args = args || {}; - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getAzureIntegration:getAzureIntegration", { "integrationId": args.integrationId, "name": args.name, @@ -95,9 +91,22 @@ export interface GetAzureIntegrationResult { */ readonly tenantId: string; } - +/** + * `spacelift.AzureIntegration` represents an integration with an Azure AD tenant. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. Note that you will need to provide admin consent manually for the integration to work + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const example = spacelift.getAzureIntegration({ + * name: "Production", + * }); + * ``` + */ export function getAzureIntegrationOutput(args?: GetAzureIntegrationOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getAzureIntegration(a, opts)) + return pulumi.output(args).apply((a: any) => getAzureIntegration(a, opts)) } /** diff --git a/sdk/nodejs/getAzureIntegrationAttachment.ts b/sdk/nodejs/getAzureIntegrationAttachment.ts index 4ced694..8617d71 100644 --- a/sdk/nodejs/getAzureIntegrationAttachment.ts +++ b/sdk/nodejs/getAzureIntegrationAttachment.ts @@ -13,18 +13,15 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const example = pulumi.output(spacelift.getAzureIntegrationAttachment({ + * const example = spacelift.getAzureIntegrationAttachment({ * integrationId: "some-integration-id", * stackId: "some-stack-id", - * })); + * }); * ``` */ export function getAzureIntegrationAttachment(args: GetAzureIntegrationAttachmentArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getAzureIntegrationAttachment:getAzureIntegrationAttachment", { "integrationId": args.integrationId, "moduleId": args.moduleId, @@ -87,9 +84,23 @@ export interface GetAzureIntegrationAttachmentResult { */ readonly write: boolean; } - +/** + * `spacelift.AzureIntegrationAttachment` represents the attachment between a reusable Azure integration and a single stack or module. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const example = spacelift.getAzureIntegrationAttachment({ + * integrationId: "some-integration-id", + * stackId: "some-stack-id", + * }); + * ``` + */ export function getAzureIntegrationAttachmentOutput(args: GetAzureIntegrationAttachmentOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getAzureIntegrationAttachment(a, opts)) + return pulumi.output(args).apply((a: any) => getAzureIntegrationAttachment(a, opts)) } /** diff --git a/sdk/nodejs/getAzureIntegrations.ts b/sdk/nodejs/getAzureIntegrations.ts new file mode 100644 index 0000000..c74e81d --- /dev/null +++ b/sdk/nodejs/getAzureIntegrations.ts @@ -0,0 +1,34 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * `spacelift.getAzureIntegrations` represents a list of all the Azure integrations in the Spacelift account visible to the API user. + */ +export function getAzureIntegrations(opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getAzureIntegrations:getAzureIntegrations", { + }, opts); +} + +/** + * A collection of values returned by getAzureIntegrations. + */ +export interface GetAzureIntegrationsResult { + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + readonly integrations: outputs.GetAzureIntegrationsIntegration[]; +} +/** + * `spacelift.getAzureIntegrations` represents a list of all the Azure integrations in the Spacelift account visible to the API user. + */ +export function getAzureIntegrationsOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getAzureIntegrations(opts)) +} diff --git a/sdk/nodejs/getBitbucketCloudIntegration.ts b/sdk/nodejs/getBitbucketCloudIntegration.ts index 17e9537..a71623b 100644 --- a/sdk/nodejs/getBitbucketCloudIntegration.ts +++ b/sdk/nodejs/getBitbucketCloudIntegration.ts @@ -13,15 +13,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const bitbucketCloudIntegration = pulumi.output(spacelift.getBitbucketCloudIntegration()); + * const bitbucketCloudIntegration = spacelift.getBitbucketCloudIntegration({}); * ``` */ export function getBitbucketCloudIntegration(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getBitbucketCloudIntegration:getBitbucketCloudIntegration", { }, opts); } @@ -39,3 +36,18 @@ export interface GetBitbucketCloudIntegrationResult { */ readonly username: string; } +/** + * `spacelift.getBitbucketCloudIntegration` returns details about Bitbucket Cloud integration + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const bitbucketCloudIntegration = spacelift.getBitbucketCloudIntegration({}); + * ``` + */ +export function getBitbucketCloudIntegrationOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getBitbucketCloudIntegration(opts)) +} diff --git a/sdk/nodejs/getBitbucketDatacenterIntegration.ts b/sdk/nodejs/getBitbucketDatacenterIntegration.ts index 58887b0..dcee0a3 100644 --- a/sdk/nodejs/getBitbucketDatacenterIntegration.ts +++ b/sdk/nodejs/getBitbucketDatacenterIntegration.ts @@ -13,15 +13,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const bitbucketDatacenterIntegration = pulumi.output(spacelift.getBitbucketDatacenterIntegration()); + * const bitbucketDatacenterIntegration = spacelift.getBitbucketDatacenterIntegration({}); * ``` */ export function getBitbucketDatacenterIntegration(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getBitbucketDatacenterIntegration:getBitbucketDatacenterIntegration", { }, opts); } @@ -46,4 +43,23 @@ export interface GetBitbucketDatacenterIntegrationResult { * Bitbucket Datacenter integration webhook secret */ readonly webhookSecret: string; + /** + * Bitbucket Datacenter integration webhook URL + */ + readonly webhookUrl: string; +} +/** + * `spacelift.getBitbucketDatacenterIntegration` returns details about Bitbucket Datacenter integration + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const bitbucketDatacenterIntegration = spacelift.getBitbucketDatacenterIntegration({}); + * ``` + */ +export function getBitbucketDatacenterIntegrationOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getBitbucketDatacenterIntegration(opts)) } diff --git a/sdk/nodejs/getContext.ts b/sdk/nodejs/getContext.ts index a5d4ca7..982b1bb 100644 --- a/sdk/nodejs/getContext.ts +++ b/sdk/nodejs/getContext.ts @@ -13,17 +13,14 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const prod_k8s_ie = pulumi.output(spacelift.getContext({ + * const prod-k8s-ie = spacelift.getContext({ * contextId: "prod-k8s-ie", - * })); + * }); * ``` */ export function getContext(args: GetContextArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getContext:getContext", { "contextId": args.contextId, }, opts); @@ -65,9 +62,22 @@ export interface GetContextResult { */ readonly spaceId: string; } - +/** + * `spacelift.Context` represents a Spacelift **context** - a collection of configuration elements (either environment variables or mounted files) that can be administratively attached to multiple stacks (`spacelift.Stack`) or modules (`spacelift.Module`) using a context attachment (`spacelift.ContextAttachment`)` + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const prod-k8s-ie = spacelift.getContext({ + * contextId: "prod-k8s-ie", + * }); + * ``` + */ export function getContextOutput(args: GetContextOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getContext(a, opts)) + return pulumi.output(args).apply((a: any) => getContext(a, opts)) } /** diff --git a/sdk/nodejs/getContextAttachment.ts b/sdk/nodejs/getContextAttachment.ts index 595e682..8c15ca0 100644 --- a/sdk/nodejs/getContextAttachment.ts +++ b/sdk/nodejs/getContextAttachment.ts @@ -13,24 +13,19 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // With a stack. - * const apps_k8s_ie = pulumi.output(spacelift.getContextAttachment({ + * const apps-k8s-ie = spacelift.getContextAttachment({ * contextId: "prod-k8s-ie", * stackId: "apps-cluster", - * })); - * // With a module. - * const kafka_k8s_ie = pulumi.output(spacelift.getContextAttachment({ + * }); + * const kafka-k8s-ie = spacelift.getContextAttachment({ * contextId: "prod-k8s-ie", * moduleId: "terraform-aws-kafka", - * })); + * }); * ``` */ export function getContextAttachment(args: GetContextAttachmentArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getContextAttachment:getContextAttachment", { "contextId": args.contextId, "moduleId": args.moduleId, @@ -81,9 +76,27 @@ export interface GetContextAttachmentResult { */ readonly stackId?: string; } - +/** + * `spacelift.ContextAttachment` represents a Spacelift attachment of a single context to a single stack or module, with a predefined priority. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const apps-k8s-ie = spacelift.getContextAttachment({ + * contextId: "prod-k8s-ie", + * stackId: "apps-cluster", + * }); + * const kafka-k8s-ie = spacelift.getContextAttachment({ + * contextId: "prod-k8s-ie", + * moduleId: "terraform-aws-kafka", + * }); + * ``` + */ export function getContextAttachmentOutput(args: GetContextAttachmentOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getContextAttachment(a, opts)) + return pulumi.output(args).apply((a: any) => getContextAttachment(a, opts)) } /** diff --git a/sdk/nodejs/getContexts.ts b/sdk/nodejs/getContexts.ts new file mode 100644 index 0000000..5be4f5a --- /dev/null +++ b/sdk/nodejs/getContexts.ts @@ -0,0 +1,96 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * `spacelift.getContexts` represents all the contexts in the Spacelift account visible to the API user. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const contexts = spacelift.getContexts({ + * labels: [ + * { + * anyOfs: [ + * "foo", + * "bar", + * ], + * }, + * { + * anyOfs: ["baz"], + * }, + * ], + * }); + * ``` + */ +export function getContexts(args?: GetContextsArgs, opts?: pulumi.InvokeOptions): Promise { + args = args || {}; + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getContexts:getContexts", { + "labels": args.labels, + }, opts); +} + +/** + * A collection of arguments for invoking getContexts. + */ +export interface GetContextsArgs { + labels?: inputs.GetContextsLabel[]; +} + +/** + * A collection of values returned by getContexts. + */ +export interface GetContextsResult { + readonly contexts: outputs.GetContextsContext[]; + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + /** + * Require contexts to have one of the labels + */ + readonly labels?: outputs.GetContextsLabel[]; +} +/** + * `spacelift.getContexts` represents all the contexts in the Spacelift account visible to the API user. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const contexts = spacelift.getContexts({ + * labels: [ + * { + * anyOfs: [ + * "foo", + * "bar", + * ], + * }, + * { + * anyOfs: ["baz"], + * }, + * ], + * }); + * ``` + */ +export function getContextsOutput(args?: GetContextsOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(args).apply((a: any) => getContexts(a, opts)) +} + +/** + * A collection of arguments for invoking getContexts. + */ +export interface GetContextsOutputArgs { + labels?: pulumi.Input[]>; +} diff --git a/sdk/nodejs/getCurrentSpace.ts b/sdk/nodejs/getCurrentSpace.ts new file mode 100644 index 0000000..daf9369 --- /dev/null +++ b/sdk/nodejs/getCurrentSpace.ts @@ -0,0 +1,59 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.getCurrentSpace` is a data source that provides information about the space that an administrative stack is in if the run is executed within Spacelift by a stack or module. This makes it easier to create resources within the same space. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const this = spacelift.getCurrentSpace({}); + * const prod_k8s_ie = new spacelift.Context("prod-k8s-ie", { + * description: "Configuration details for the compute cluster in 🇮🇪", + * spaceId: _this.then(_this => _this.id), + * }); + * ``` + */ +export function getCurrentSpace(opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getCurrentSpace:getCurrentSpace", { + }, opts); +} + +/** + * A collection of values returned by getCurrentSpace. + */ +export interface GetCurrentSpaceResult { + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; +} +/** + * `spacelift.getCurrentSpace` is a data source that provides information about the space that an administrative stack is in if the run is executed within Spacelift by a stack or module. This makes it easier to create resources within the same space. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const this = spacelift.getCurrentSpace({}); + * const prod_k8s_ie = new spacelift.Context("prod-k8s-ie", { + * description: "Configuration details for the compute cluster in 🇮🇪", + * spaceId: _this.then(_this => _this.id), + * }); + * ``` + */ +export function getCurrentSpaceOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getCurrentSpace(opts)) +} diff --git a/sdk/nodejs/getCurrentStack.ts b/sdk/nodejs/getCurrentStack.ts index d24845d..efa399b 100644 --- a/sdk/nodejs/getCurrentStack.ts +++ b/sdk/nodejs/getCurrentStack.ts @@ -22,11 +22,8 @@ import * as utilities from "./utilities"; * ``` */ export function getCurrentStack(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getCurrentStack:getCurrentStack", { }, opts); } @@ -40,3 +37,23 @@ export interface GetCurrentStackResult { */ readonly id: string; } +/** + * `spacelift.getCurrentStack` is a data source that provides information about the current administrative stack if the run is executed within Spacelift by a stack or module. This allows clever tricks like attaching contexts or policies to the stack that manages them. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const this = spacelift.getCurrentStack({}); + * const core_kubeconfig = new spacelift.EnvironmentVariable("core-kubeconfig", { + * stackId: _this.then(_this => _this.id), + * value: "bacon", + * }); + * ``` + */ +export function getCurrentStackOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getCurrentStack(opts)) +} diff --git a/sdk/nodejs/getDriftDetection.ts b/sdk/nodejs/getDriftDetection.ts index 0b29c25..09c2ac3 100644 --- a/sdk/nodejs/getDriftDetection.ts +++ b/sdk/nodejs/getDriftDetection.ts @@ -13,18 +13,16 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const core_infra_production_drift_detection = pulumi.output(spacelift.getDriftDetection({ + * const core-infra-production-drift-detection = spacelift.getDriftDetection({ * stackId: "core-infra-production", - * })); + * }); * ``` */ export function getDriftDetection(args: GetDriftDetectionArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getDriftDetection:getDriftDetection", { + "ignoreState": args.ignoreState, "stackId": args.stackId, }, opts); } @@ -33,6 +31,10 @@ export function getDriftDetection(args: GetDriftDetectionArgs, opts?: pulumi.Inv * A collection of arguments for invoking getDriftDetection. */ export interface GetDriftDetectionArgs { + /** + * Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + */ + ignoreState?: boolean; /** * ID of the stack for which to set up drift detection */ @@ -47,6 +49,10 @@ export interface GetDriftDetectionResult { * The provider-assigned unique ID for this managed resource. */ readonly id: string; + /** + * Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + */ + readonly ignoreState?: boolean; /** * Whether a tracked run should be triggered when drift is detected. */ @@ -64,15 +70,32 @@ export interface GetDriftDetectionResult { */ readonly timezone: string; } - +/** + * `spacelift.DriftDetection` represents a Drift Detection configuration for a Stack. It will trigger a proposed run on the given schedule, which you can listen for using run state webhooks. If reconcile is true, then a tracked run will be triggered when drift is detected. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const core-infra-production-drift-detection = spacelift.getDriftDetection({ + * stackId: "core-infra-production", + * }); + * ``` + */ export function getDriftDetectionOutput(args: GetDriftDetectionOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getDriftDetection(a, opts)) + return pulumi.output(args).apply((a: any) => getDriftDetection(a, opts)) } /** * A collection of arguments for invoking getDriftDetection. */ export interface GetDriftDetectionOutputArgs { + /** + * Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + */ + ignoreState?: pulumi.Input; /** * ID of the stack for which to set up drift detection */ diff --git a/sdk/nodejs/getEnvironmentVariable.ts b/sdk/nodejs/getEnvironmentVariable.ts index 99107f1..1d6d6b1 100644 --- a/sdk/nodejs/getEnvironmentVariable.ts +++ b/sdk/nodejs/getEnvironmentVariable.ts @@ -13,29 +13,23 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // For a context - * const ireland_kubeconfig = pulumi.output(spacelift.getEnvironmentVariable({ + * const ireland-kubeconfig = spacelift.getEnvironmentVariable({ * contextId: "prod-k8s-ie", * name: "KUBECONFIG", - * })); - * // For a module - * const module_kubeconfig = pulumi.output(spacelift.getEnvironmentVariable({ + * }); + * const module-kubeconfig = spacelift.getEnvironmentVariable({ * moduleId: "k8s-module", * name: "KUBECONFIG", - * })); - * // For a stack - * const core_kubeconfig = pulumi.output(spacelift.getEnvironmentVariable({ + * }); + * const core-kubeconfig = spacelift.getEnvironmentVariable({ * name: "KUBECONFIG", * stackId: "k8s-core", - * })); + * }); * ``` */ export function getEnvironmentVariable(args: GetEnvironmentVariableArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getEnvironmentVariable:getEnvironmentVariable", { "contextId": args.contextId, "moduleId": args.moduleId, @@ -103,9 +97,31 @@ export interface GetEnvironmentVariableResult { */ readonly writeOnly: boolean; } - +/** + * `spacelift.EnvironmentVariable` defines an environment variable on the context (`spacelift.Context`), stack (`spacelift.Stack`) or a module (`spacelift.Module`), thereby allowing to pass and share various secrets and configuration with Spacelift stacks. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const ireland-kubeconfig = spacelift.getEnvironmentVariable({ + * contextId: "prod-k8s-ie", + * name: "KUBECONFIG", + * }); + * const module-kubeconfig = spacelift.getEnvironmentVariable({ + * moduleId: "k8s-module", + * name: "KUBECONFIG", + * }); + * const core-kubeconfig = spacelift.getEnvironmentVariable({ + * name: "KUBECONFIG", + * stackId: "k8s-core", + * }); + * ``` + */ export function getEnvironmentVariableOutput(args: GetEnvironmentVariableOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getEnvironmentVariable(a, opts)) + return pulumi.output(args).apply((a: any) => getEnvironmentVariable(a, opts)) } /** diff --git a/sdk/nodejs/getGcpServiceAccount.ts b/sdk/nodejs/getGcpServiceAccount.ts index 97fd393..7b58602 100644 --- a/sdk/nodejs/getGcpServiceAccount.ts +++ b/sdk/nodejs/getGcpServiceAccount.ts @@ -11,23 +11,18 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // For a Module - * const k8s_module = pulumi.output(spacelift.getGcpServiceAccount({ + * const k8s-module = spacelift.getGcpServiceAccount({ * moduleId: "k8s-module", - * })); - * // For a Stack - * const k8s_core = pulumi.output(spacelift.getGcpServiceAccount({ + * }); + * const k8s-core = spacelift.getGcpServiceAccount({ * stackId: "k8s-core", - * })); + * }); * ``` */ export function getGcpServiceAccount(args?: GetGcpServiceAccountArgs, opts?: pulumi.InvokeOptions): Promise { args = args || {}; - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getGcpServiceAccount:getGcpServiceAccount", { "moduleId": args.moduleId, "stackId": args.stackId, @@ -73,9 +68,23 @@ export interface GetGcpServiceAccountResult { */ readonly tokenScopes: string[]; } - +/** + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const k8s-module = spacelift.getGcpServiceAccount({ + * moduleId: "k8s-module", + * }); + * const k8s-core = spacelift.getGcpServiceAccount({ + * stackId: "k8s-core", + * }); + * ``` + */ export function getGcpServiceAccountOutput(args?: GetGcpServiceAccountOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getGcpServiceAccount(a, opts)) + return pulumi.output(args).apply((a: any) => getGcpServiceAccount(a, opts)) } /** diff --git a/sdk/nodejs/getGithubEnterpriseIntegration.ts b/sdk/nodejs/getGithubEnterpriseIntegration.ts index 224a03b..ae7bc1b 100644 --- a/sdk/nodejs/getGithubEnterpriseIntegration.ts +++ b/sdk/nodejs/getGithubEnterpriseIntegration.ts @@ -13,15 +13,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const githubEnterpriseIntegration = pulumi.output(spacelift.getGithubEnterpriseIntegration()); + * const githubEnterpriseIntegration = spacelift.getGithubEnterpriseIntegration({}); * ``` */ export function getGithubEnterpriseIntegration(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getGithubEnterpriseIntegration:getGithubEnterpriseIntegration", { }, opts); } @@ -47,3 +44,18 @@ export interface GetGithubEnterpriseIntegrationResult { */ readonly webhookSecret: string; } +/** + * `spacelift.getGithubEnterpriseIntegration` returns details about Github Enterprise integration + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const githubEnterpriseIntegration = spacelift.getGithubEnterpriseIntegration({}); + * ``` + */ +export function getGithubEnterpriseIntegrationOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getGithubEnterpriseIntegration(opts)) +} diff --git a/sdk/nodejs/getGitlabIntegration.ts b/sdk/nodejs/getGitlabIntegration.ts index 6e8bd6e..a29b7e0 100644 --- a/sdk/nodejs/getGitlabIntegration.ts +++ b/sdk/nodejs/getGitlabIntegration.ts @@ -13,15 +13,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const gitlabIntegration = pulumi.output(spacelift.getGitlabIntegration()); + * const gitlabIntegration = spacelift.getGitlabIntegration({}); * ``` */ export function getGitlabIntegration(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getGitlabIntegration:getGitlabIntegration", { }, opts); } @@ -43,3 +40,18 @@ export interface GetGitlabIntegrationResult { */ readonly webhookSecret: string; } +/** + * `spacelift.getGitlabIntegration` returns details about Gitlab integration + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const gitlabIntegration = spacelift.getGitlabIntegration({}); + * ``` + */ +export function getGitlabIntegrationOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getGitlabIntegration(opts)) +} diff --git a/sdk/nodejs/getGitlabWebhookEndpoint.ts b/sdk/nodejs/getGitlabWebhookEndpoint.ts new file mode 100644 index 0000000..a4d95e1 --- /dev/null +++ b/sdk/nodejs/getGitlabWebhookEndpoint.ts @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.getGitlabWebhookEndpoint` returns details about Gitlab webhook endpoint + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const this = spacelift.getGitlabWebhookEndpoint({}); + * ``` + */ +export function getGitlabWebhookEndpoint(opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getGitlabWebhookEndpoint:getGitlabWebhookEndpoint", { + }, opts); +} + +/** + * A collection of values returned by getGitlabWebhookEndpoint. + */ +export interface GetGitlabWebhookEndpointResult { + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + /** + * Gitlab webhook endpoint address + */ + readonly webhookEndpoint: string; +} +/** + * `spacelift.getGitlabWebhookEndpoint` returns details about Gitlab webhook endpoint + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const this = spacelift.getGitlabWebhookEndpoint({}); + * ``` + */ +export function getGitlabWebhookEndpointOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getGitlabWebhookEndpoint(opts)) +} diff --git a/sdk/nodejs/getIPs.ts b/sdk/nodejs/getIPs.ts index 4163cae..2bba58d 100644 --- a/sdk/nodejs/getIPs.ts +++ b/sdk/nodejs/getIPs.ts @@ -5,7 +5,7 @@ import * as pulumi from "@pulumi/pulumi"; import * as utilities from "./utilities"; /** - * `spacelift.getIPs` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". + * `spacelift.getIPs` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". **NOTE:** this does not include the IP addresses of the workers in Spacelift's public worker pool. If you need to ensure that requests made during runs originate from a known set of IP addresses, please consider setting up a [private worker pool](https://docs.spacelift.io/concepts/worker-pools). * * ## Example Usage * @@ -13,15 +13,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const ips = pulumi.output(spacelift.getIPs()); + * const ips = spacelift.getIPs({}); * ``` */ export function getIPs(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getIPs:getIPs", { }, opts); } @@ -39,3 +36,18 @@ export interface GetIPsResult { */ readonly ips: string[]; } +/** + * `spacelift.getIPs` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". **NOTE:** this does not include the IP addresses of the workers in Spacelift's public worker pool. If you need to ensure that requests made during runs originate from a known set of IP addresses, please consider setting up a [private worker pool](https://docs.spacelift.io/concepts/worker-pools). + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const ips = spacelift.getIPs({}); + * ``` + */ +export function getIPsOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getIPs(opts)) +} diff --git a/sdk/nodejs/getModule.ts b/sdk/nodejs/getModule.ts index 9a09c93..f965b89 100644 --- a/sdk/nodejs/getModule.ts +++ b/sdk/nodejs/getModule.ts @@ -13,17 +13,14 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const k8s_module = pulumi.output(spacelift.getModule({ + * const k8s-module = spacelift.getModule({ * moduleId: "k8s-module", - * })); + * }); * ``` */ export function getModule(args: GetModuleArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getModule:getModule", { "moduleId": args.moduleId, }, opts); @@ -71,6 +68,10 @@ export interface GetModuleResult { * free-form module description for human users (supports Markdown) */ readonly description: string; + /** + * Indicates whether local preview versions can be triggered on this Module. + */ + readonly enableLocalPreview: boolean; /** * GitHub Enterprise (self-hosted) VCS settings */ @@ -114,10 +115,25 @@ export interface GetModuleResult { * ID of the worker pool to use */ readonly workerPoolId: string; + /** + * Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. + */ + readonly workflowTool: string; } - +/** + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const k8s-module = spacelift.getModule({ + * moduleId: "k8s-module", + * }); + * ``` + */ export function getModuleOutput(args: GetModuleOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getModule(a, opts)) + return pulumi.output(args).apply((a: any) => getModule(a, opts)) } /** diff --git a/sdk/nodejs/getMountedfile.ts b/sdk/nodejs/getMountedfile.ts index 122e462..71cdc4e 100644 --- a/sdk/nodejs/getMountedfile.ts +++ b/sdk/nodejs/getMountedfile.ts @@ -13,29 +13,23 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // For a context - * const ireland_kubeconfig = pulumi.output(spacelift.getMountedfile({ + * const ireland-kubeconfig = spacelift.getMountedfile({ * contextId: "prod-k8s-ie", * relativePath: "kubeconfig", - * })); - * // For a module - * const module_kubeconfig = pulumi.output(spacelift.getMountedfile({ + * }); + * const module-kubeconfig = spacelift.getMountedfile({ * moduleId: "k8s-module", * relativePath: "kubeconfig", - * })); - * // For a stack - * const core_kubeconfig = pulumi.output(spacelift.getMountedfile({ + * }); + * const core-kubeconfig = spacelift.getMountedfile({ * relativePath: "kubeconfig", * stackId: "k8s-core", - * })); + * }); * ``` */ export function getMountedfile(args: GetMountedfileArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getMountedfile:getMountedfile", { "contextId": args.contextId, "moduleId": args.moduleId, @@ -103,9 +97,31 @@ export interface GetMountedfileResult { */ readonly writeOnly: boolean; } - +/** + * `spacelift.Mountedfile` represents a file mounted in each Run's workspace that is part of a configuration of a context (`spacelift.Context`), stack (`spacelift.Stack`) or a module (`spacelift.Module`). In principle, it's very similar to an environment variable (`spacelift.EnvironmentVariable`) except that the value is written to the filesystem rather than passed to the environment. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const ireland-kubeconfig = spacelift.getMountedfile({ + * contextId: "prod-k8s-ie", + * relativePath: "kubeconfig", + * }); + * const module-kubeconfig = spacelift.getMountedfile({ + * moduleId: "k8s-module", + * relativePath: "kubeconfig", + * }); + * const core-kubeconfig = spacelift.getMountedfile({ + * relativePath: "kubeconfig", + * stackId: "k8s-core", + * }); + * ``` + */ export function getMountedfileOutput(args: GetMountedfileOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getMountedfile(a, opts)) + return pulumi.output(args).apply((a: any) => getMountedfile(a, opts)) } /** diff --git a/sdk/nodejs/getNamedWebhook.ts b/sdk/nodejs/getNamedWebhook.ts new file mode 100644 index 0000000..d78fe78 --- /dev/null +++ b/sdk/nodejs/getNamedWebhook.ts @@ -0,0 +1,84 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + */ +export function getNamedWebhook(args: GetNamedWebhookArgs, opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getNamedWebhook:getNamedWebhook", { + "webhookId": args.webhookId, + }, opts); +} + +/** + * A collection of arguments for invoking getNamedWebhook. + */ +export interface GetNamedWebhookArgs { + /** + * ID of the webhook + */ + webhookId: string; +} + +/** + * A collection of values returned by getNamedWebhook. + */ +export interface GetNamedWebhookResult { + /** + * enables or disables sending webhooks. + */ + readonly enabled: boolean; + /** + * endpoint to send the requests to + */ + readonly endpoint: string; + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + /** + * labels for the webhook to use when referring in policies or filtering them + */ + readonly labels: string[]; + /** + * the name for the webhook which will also be used to generate the id + */ + readonly name: string; + /** + * secret used to sign each request so you're able to verify that the request comes from us. + */ + readonly secret: string; + /** + * secret header keys which are currently set for this webhook + */ + readonly secretHeaderKeys: string[]; + /** + * ID of the space the webhook is in + */ + readonly spaceId: string; + /** + * ID of the webhook + */ + readonly webhookId: string; +} +/** + * `spacelift.NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + */ +export function getNamedWebhookOutput(args: GetNamedWebhookOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(args).apply((a: any) => getNamedWebhook(a, opts)) +} + +/** + * A collection of arguments for invoking getNamedWebhook. + */ +export interface GetNamedWebhookOutputArgs { + /** + * ID of the webhook + */ + webhookId: pulumi.Input; +} diff --git a/sdk/nodejs/getPolicies.ts b/sdk/nodejs/getPolicies.ts index e2e1ad1..242ea1a 100644 --- a/sdk/nodejs/getPolicies.ts +++ b/sdk/nodejs/getPolicies.ts @@ -25,11 +25,8 @@ import * as utilities from "./utilities"; */ export function getPolicies(args?: GetPoliciesArgs, opts?: pulumi.InvokeOptions): Promise { args = args || {}; - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getPolicies:getPolicies", { "labels": args.labels, "type": args.type, @@ -40,13 +37,7 @@ export function getPolicies(args?: GetPoliciesArgs, opts?: pulumi.InvokeOptions) * A collection of arguments for invoking getPolicies. */ export interface GetPoliciesArgs { - /** - * required labels to match - */ labels?: string[]; - /** - * required policy type - */ type?: string; } @@ -68,21 +59,31 @@ export interface GetPoliciesResult { */ readonly type?: string; } - +/** + * `spacelift.getPolicies` can find all policies that have certain labels. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const all = spacelift.getPolicies({}); + * const planAutoattach = spacelift.getPolicies({ + * type: "PLAN", + * labels: ["autoattach"], + * }); + * export const policyIds = data.spacelift_policies["this"].policies.map(__item => __item.id); + * ``` + */ export function getPoliciesOutput(args?: GetPoliciesOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getPolicies(a, opts)) + return pulumi.output(args).apply((a: any) => getPolicies(a, opts)) } /** * A collection of arguments for invoking getPolicies. */ export interface GetPoliciesOutputArgs { - /** - * required labels to match - */ labels?: pulumi.Input[]>; - /** - * required policy type - */ type?: pulumi.Input; } diff --git a/sdk/nodejs/getPolicy.ts b/sdk/nodejs/getPolicy.ts index 457af56..fa754a2 100644 --- a/sdk/nodejs/getPolicy.ts +++ b/sdk/nodejs/getPolicy.ts @@ -20,11 +20,8 @@ import * as utilities from "./utilities"; * ``` */ export function getPolicy(args: GetPolicyArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getPolicy:getPolicy", { "policyId": args.policyId, }, opts); @@ -70,9 +67,23 @@ export interface GetPolicyResult { */ readonly type: string; } - +/** + * `spacelift.Policy` represents a Spacelift **policy** - a collection of customer-defined rules that are applied by Spacelift at one of the decision points within the application. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const policy = spacelift.getPolicy({ + * policyId: spacelift_policy.policy.id, + * }); + * export const policyBody = policy.then(policy => policy.body); + * ``` + */ export function getPolicyOutput(args: GetPolicyOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getPolicy(a, opts)) + return pulumi.output(args).apply((a: any) => getPolicy(a, opts)) } /** diff --git a/sdk/nodejs/getScheduledDeleteStack.ts b/sdk/nodejs/getScheduledDeleteStack.ts new file mode 100644 index 0000000..d499c2d --- /dev/null +++ b/sdk/nodejs/getScheduledDeleteStack.ts @@ -0,0 +1,94 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const ireland-kubeconfig-delete = spacelift.getScheduledDeleteStack({ + * scheduledDeleteStackId: "$STACK_ID/$SCHEDULED_DELETE_STACK_ID", + * }); + * ``` + */ +export function getScheduledDeleteStack(args: GetScheduledDeleteStackArgs, opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getScheduledDeleteStack:getScheduledDeleteStack", { + "scheduledDeleteStackId": args.scheduledDeleteStackId, + }, opts); +} + +/** + * A collection of arguments for invoking getScheduledDeleteStack. + */ +export interface GetScheduledDeleteStackArgs { + /** + * ID of the scheduled delete*stack (stack*id/schedule_id) + */ + scheduledDeleteStackId: string; +} + +/** + * A collection of values returned by getScheduledDeleteStack. + */ +export interface GetScheduledDeleteStackResult { + /** + * Timestamp (unix timestamp) at which time the scheduling should happen. + */ + readonly at: number; + /** + * Indicates whether the resources of the stack should be deleted. + */ + readonly deleteResources: boolean; + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + /** + * ID of the schedule + */ + readonly scheduleId: string; + /** + * ID of the scheduled delete*stack (stack*id/schedule_id) + */ + readonly scheduledDeleteStackId: string; + /** + * Stack ID of the scheduling config + */ + readonly stackId: string; +} +/** + * `spacelift.ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const ireland-kubeconfig-delete = spacelift.getScheduledDeleteStack({ + * scheduledDeleteStackId: "$STACK_ID/$SCHEDULED_DELETE_STACK_ID", + * }); + * ``` + */ +export function getScheduledDeleteStackOutput(args: GetScheduledDeleteStackOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(args).apply((a: any) => getScheduledDeleteStack(a, opts)) +} + +/** + * A collection of arguments for invoking getScheduledDeleteStack. + */ +export interface GetScheduledDeleteStackOutputArgs { + /** + * ID of the scheduled delete*stack (stack*id/schedule_id) + */ + scheduledDeleteStackId: pulumi.Input; +} diff --git a/sdk/nodejs/getScheduledTask.ts b/sdk/nodejs/getScheduledTask.ts new file mode 100644 index 0000000..f4ff625 --- /dev/null +++ b/sdk/nodejs/getScheduledTask.ts @@ -0,0 +1,102 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.ScheduledTask` represents a scheduling configuration for a Stack. It will trigger a task on the given timestamp/schedule. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const ireland-kubeconfig-destroy = spacelift.getScheduledTask({ + * scheduledTaskId: "$STACK_ID/$SCHEDULED_TASK_ID", + * }); + * ``` + */ +export function getScheduledTask(args: GetScheduledTaskArgs, opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getScheduledTask:getScheduledTask", { + "scheduledTaskId": args.scheduledTaskId, + }, opts); +} + +/** + * A collection of arguments for invoking getScheduledTask. + */ +export interface GetScheduledTaskArgs { + /** + * ID of the scheduled task (stack*id/schedule*id) + */ + scheduledTaskId: string; +} + +/** + * A collection of values returned by getScheduledTask. + */ +export interface GetScheduledTaskResult { + /** + * Timestamp (unix timestamp) at which time the scheduling should happen. + */ + readonly at: number; + /** + * Command that will be run. + */ + readonly command: string; + /** + * List of cron schedule expressions based on which the scheduled task should be triggered. + */ + readonly everies: string[]; + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + /** + * ID of the schedule + */ + readonly scheduleId: string; + /** + * ID of the scheduled task (stack*id/schedule*id) + */ + readonly scheduledTaskId: string; + /** + * Stack ID of the scheduled task + */ + readonly stackId: string; + /** + * Timezone in which the schedule is expressed. Defaults to `UTC`. + */ + readonly timezone: string; +} +/** + * `spacelift.ScheduledTask` represents a scheduling configuration for a Stack. It will trigger a task on the given timestamp/schedule. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const ireland-kubeconfig-destroy = spacelift.getScheduledTask({ + * scheduledTaskId: "$STACK_ID/$SCHEDULED_TASK_ID", + * }); + * ``` + */ +export function getScheduledTaskOutput(args: GetScheduledTaskOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(args).apply((a: any) => getScheduledTask(a, opts)) +} + +/** + * A collection of arguments for invoking getScheduledTask. + */ +export interface GetScheduledTaskOutputArgs { + /** + * ID of the scheduled task (stack*id/schedule*id) + */ + scheduledTaskId: pulumi.Input; +} diff --git a/sdk/nodejs/getSpace.ts b/sdk/nodejs/getSpace.ts index ef88615..616d619 100644 --- a/sdk/nodejs/getSpace.ts +++ b/sdk/nodejs/getSpace.ts @@ -20,11 +20,8 @@ import * as utilities from "./utilities"; * ``` */ export function getSpace(args: GetSpaceArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getSpace:getSpace", { "spaceId": args.spaceId, }, opts); @@ -56,6 +53,10 @@ export interface GetSpaceResult { * indication whether access to this space inherits read access to entities from the parent space */ readonly inheritEntities: boolean; + /** + * list of labels describing a space + */ + readonly labels: string[]; /** * name of the space */ @@ -69,9 +70,23 @@ export interface GetSpaceResult { */ readonly spaceId: string; } - +/** + * `spacelift.Space` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const space = spacelift.getSpace({ + * spaceId: spacelift_space.space.id, + * }); + * export const spaceDescription = space.then(space => space.description); + * ``` + */ export function getSpaceOutput(args: GetSpaceOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getSpace(a, opts)) + return pulumi.output(args).apply((a: any) => getSpace(a, opts)) } /** diff --git a/sdk/nodejs/getSpaceByPath.ts b/sdk/nodejs/getSpaceByPath.ts new file mode 100644 index 0000000..43c924a --- /dev/null +++ b/sdk/nodejs/getSpaceByPath.ts @@ -0,0 +1,104 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.getSpaceByPath` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. In contrary to `spacelift.Space`, this resource is identified by a path, not by an ID. For this data source to work, path must be unique. If there are multiple spaces with the same path, this datasource will fail. + * **Disclaimer:** + * This datasource can only be used in a stack that resides in a space with inheritance enabled. In addition, the parent spaces (excluding root) must also have inheritance enabled. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const space = spacelift.getSpaceByPath({ + * spacePath: "root/second space/my space", + * }); + * export const spaceDescription = space.then(space => space.description); + * ``` + */ +export function getSpaceByPath(args: GetSpaceByPathArgs, opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getSpaceByPath:getSpaceByPath", { + "spacePath": args.spacePath, + }, opts); +} + +/** + * A collection of arguments for invoking getSpaceByPath. + */ +export interface GetSpaceByPathArgs { + /** + * path to the space - a series of space names separated by `/` + */ + spacePath: string; +} + +/** + * A collection of values returned by getSpaceByPath. + */ +export interface GetSpaceByPathResult { + /** + * free-form space description for users + */ + readonly description: string; + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + /** + * indication whether access to this space inherits read access to entities from the parent space + */ + readonly inheritEntities: boolean; + /** + * list of labels describing a space + */ + readonly labels: string[]; + /** + * name of the space + */ + readonly name: string; + /** + * immutable ID (slug) of parent space + */ + readonly parentSpaceId: string; + /** + * path to the space - a series of space names separated by `/` + */ + readonly spacePath: string; +} +/** + * `spacelift.getSpaceByPath` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. In contrary to `spacelift.Space`, this resource is identified by a path, not by an ID. For this data source to work, path must be unique. If there are multiple spaces with the same path, this datasource will fail. + * **Disclaimer:** + * This datasource can only be used in a stack that resides in a space with inheritance enabled. In addition, the parent spaces (excluding root) must also have inheritance enabled. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const space = spacelift.getSpaceByPath({ + * spacePath: "root/second space/my space", + * }); + * export const spaceDescription = space.then(space => space.description); + * ``` + */ +export function getSpaceByPathOutput(args: GetSpaceByPathOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(args).apply((a: any) => getSpaceByPath(a, opts)) +} + +/** + * A collection of arguments for invoking getSpaceByPath. + */ +export interface GetSpaceByPathOutputArgs { + /** + * path to the space - a series of space names separated by `/` + */ + spacePath: pulumi.Input; +} diff --git a/sdk/nodejs/getSpaces.ts b/sdk/nodejs/getSpaces.ts new file mode 100644 index 0000000..e50c37c --- /dev/null +++ b/sdk/nodejs/getSpaces.ts @@ -0,0 +1,54 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * `spacelift.getSpaces` can find all spaces in the spacelift organization. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const this = spacelift.getSpaces({}); + * export const spaces = _this.then(_this => _this.spaces); + * ``` + */ +export function getSpaces(opts?: pulumi.InvokeOptions): Promise { + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getSpaces:getSpaces", { + }, opts); +} + +/** + * A collection of values returned by getSpaces. + */ +export interface GetSpacesResult { + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + readonly spaces: outputs.GetSpacesSpace[]; +} +/** + * `spacelift.getSpaces` can find all spaces in the spacelift organization. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const this = spacelift.getSpaces({}); + * export const spaces = _this.then(_this => _this.spaces); + * ``` + */ +export function getSpacesOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getSpaces(opts)) +} diff --git a/sdk/nodejs/getStack.ts b/sdk/nodejs/getStack.ts index 2592eb5..4c70a8e 100644 --- a/sdk/nodejs/getStack.ts +++ b/sdk/nodejs/getStack.ts @@ -15,23 +15,21 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const k8s_core = pulumi.output(spacelift.getStack({ + * const k8s-core = spacelift.getStack({ * stackId: "k8s-core", - * })); + * }); * ``` */ export function getStack(args: GetStackArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getStack:getStack", { "afterApplies": args.afterApplies, "afterDestroys": args.afterDestroys, "afterInits": args.afterInits, "afterPerforms": args.afterPerforms, "afterPlans": args.afterPlans, + "afterRuns": args.afterRuns, "beforeApplies": args.beforeApplies, "beforeDestroys": args.beforeDestroys, "beforeInits": args.beforeInits, @@ -65,6 +63,10 @@ export interface GetStackArgs { * List of after-plan scripts */ afterPlans?: string[]; + /** + * List of after-run scripts + */ + afterRuns?: string[]; /** * List of before-apply scripts */ @@ -102,23 +104,27 @@ export interface GetStackResult { /** * List of after-apply scripts */ - readonly afterApplies?: string[]; + readonly afterApplies: string[]; /** * List of after-destroy scripts */ - readonly afterDestroys?: string[]; + readonly afterDestroys: string[]; /** * List of after-init scripts */ - readonly afterInits?: string[]; + readonly afterInits: string[]; /** * List of after-perform scripts */ - readonly afterPerforms?: string[]; + readonly afterPerforms: string[]; /** * List of after-plan scripts */ - readonly afterPlans?: string[]; + readonly afterPlans: string[]; + /** + * List of after-run scripts + */ + readonly afterRuns?: string[]; /** * Ansible-specific configuration. Presence means this Stack is an Ansible Stack. */ @@ -142,23 +148,23 @@ export interface GetStackResult { /** * List of before-apply scripts */ - readonly beforeApplies?: string[]; + readonly beforeApplies: string[]; /** * List of before-destroy scripts */ - readonly beforeDestroys?: string[]; + readonly beforeDestroys: string[]; /** * List of before-init scripts */ - readonly beforeInits?: string[]; + readonly beforeInits: string[]; /** * List of before-perform scripts */ - readonly beforePerforms?: string[]; + readonly beforePerforms: string[]; /** * List of before-plan scripts */ - readonly beforePlans?: string[]; + readonly beforePlans: string[]; /** * Bitbucket Cloud VCS settings */ @@ -220,6 +226,10 @@ export interface GetStackResult { * Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. */ readonly pulumis: outputs.GetStackPulumi[]; + /** + * One-way VCS integration using a raw Git repository link + */ + readonly rawGits: outputs.GetStackRawGit[]; /** * Name of the repository, without the owner part */ @@ -240,17 +250,38 @@ export interface GetStackResult { * ID (slug) of the stack */ readonly stackId: string; + /** + * Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. + */ + readonly terraformExternalStateAccess: boolean; readonly terraformSmartSanitization: boolean; readonly terraformVersion: string; + /** + * Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. + */ + readonly terraformWorkflowTool: string; readonly terraformWorkspace: string; /** * ID of the worker pool to use */ readonly workerPoolId: string; } - +/** + * `spacelift.Stack` combines source code and configuration to create a runtime environment where resources are managed. In this way it's similar to a stack in AWS CloudFormation, or a project on generic CI/CD platforms. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const k8s-core = spacelift.getStack({ + * stackId: "k8s-core", + * }); + * ``` + */ export function getStackOutput(args: GetStackOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getStack(a, opts)) + return pulumi.output(args).apply((a: any) => getStack(a, opts)) } /** @@ -277,6 +308,10 @@ export interface GetStackOutputArgs { * List of after-plan scripts */ afterPlans?: pulumi.Input[]>; + /** + * List of after-run scripts + */ + afterRuns?: pulumi.Input[]>; /** * List of before-apply scripts */ diff --git a/sdk/nodejs/getStackAwsRole.ts b/sdk/nodejs/getStackAwsRole.ts index 2f834e8..7d556ca 100644 --- a/sdk/nodejs/getStackAwsRole.ts +++ b/sdk/nodejs/getStackAwsRole.ts @@ -19,23 +19,18 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // For a Module - * const k8s_module = pulumi.output(spacelift.getStackAwsRole({ + * const k8s-module = spacelift.getStackAwsRole({ * moduleId: "k8s-module", - * })); - * // For a Stack - * const k8s_core = pulumi.output(spacelift.getStackAwsRole({ + * }); + * const k8s-core = spacelift.getStackAwsRole({ * stackId: "k8s-core", - * })); + * }); * ``` */ export function getStackAwsRole(args?: GetStackAwsRoleArgs, opts?: pulumi.InvokeOptions): Promise { args = args || {}; - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getStackAwsRole:getStackAwsRole", { "moduleId": args.moduleId, "stackId": args.stackId, @@ -89,9 +84,31 @@ export interface GetStackAwsRoleResult { */ readonly stackId?: string; } - +/** + * > **Note:** `spacelift.StackAwsRole` is deprecated. Please use `spacelift.AwsRole` instead. The functionality is identical. + * + * `spacelift.StackAwsRole` represents [cross-account IAM role delegation](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) between the Spacelift worker and an individual stack or module. If this is set, Spacelift will use AWS STS to assume the supplied IAM role and put its temporary credentials in the runtime environment. + * + * If you use private workers, you can also assume IAM role on the worker side using your own AWS credentials (e.g. from EC2 instance profile). + * + * Note: when assuming credentials for **shared worker**, Spacelift will use `$accountName@$stackID` or `$accountName@$moduleID` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole). + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const k8s-module = spacelift.getStackAwsRole({ + * moduleId: "k8s-module", + * }); + * const k8s-core = spacelift.getStackAwsRole({ + * stackId: "k8s-core", + * }); + * ``` + */ export function getStackAwsRoleOutput(args?: GetStackAwsRoleOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getStackAwsRole(a, opts)) + return pulumi.output(args).apply((a: any) => getStackAwsRole(a, opts)) } /** diff --git a/sdk/nodejs/getStackGcpServiceAccount.ts b/sdk/nodejs/getStackGcpServiceAccount.ts index 4bbd2ca..b50a4a2 100644 --- a/sdk/nodejs/getStackGcpServiceAccount.ts +++ b/sdk/nodejs/getStackGcpServiceAccount.ts @@ -11,23 +11,18 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * // For a Module - * const k8s_module = pulumi.output(spacelift.getStackGcpServiceAccount({ + * const k8s-module = spacelift.getStackGcpServiceAccount({ * moduleId: "k8s-module", - * })); - * // For a Stack - * const k8s_core = pulumi.output(spacelift.getStackGcpServiceAccount({ + * }); + * const k8s-core = spacelift.getStackGcpServiceAccount({ * stackId: "k8s-core", - * })); + * }); * ``` */ export function getStackGcpServiceAccount(args?: GetStackGcpServiceAccountArgs, opts?: pulumi.InvokeOptions): Promise { args = args || {}; - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getStackGcpServiceAccount:getStackGcpServiceAccount", { "moduleId": args.moduleId, "stackId": args.stackId, @@ -73,9 +68,23 @@ export interface GetStackGcpServiceAccountResult { */ readonly tokenScopes: string[]; } - +/** + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const k8s-module = spacelift.getStackGcpServiceAccount({ + * moduleId: "k8s-module", + * }); + * const k8s-core = spacelift.getStackGcpServiceAccount({ + * stackId: "k8s-core", + * }); + * ``` + */ export function getStackGcpServiceAccountOutput(args?: GetStackGcpServiceAccountOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getStackGcpServiceAccount(a, opts)) + return pulumi.output(args).apply((a: any) => getStackGcpServiceAccount(a, opts)) } /** diff --git a/sdk/nodejs/getStacks.ts b/sdk/nodejs/getStacks.ts new file mode 100644 index 0000000..3678d18 --- /dev/null +++ b/sdk/nodejs/getStacks.ts @@ -0,0 +1,157 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * `spacelift.getStacks` represents all the stacks in the Spacelift account visible to the API user, matching predicates. + */ +export function getStacks(args?: GetStacksArgs, opts?: pulumi.InvokeOptions): Promise { + args = args || {}; + + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("spacelift:index/getStacks:getStacks", { + "administrative": args.administrative, + "branch": args.branch, + "commit": args.commit, + "labels": args.labels, + "locked": args.locked, + "name": args.name, + "projectRoot": args.projectRoot, + "repository": args.repository, + "state": args.state, + "vendor": args.vendor, + "workerPool": args.workerPool, + }, opts); +} + +/** + * A collection of arguments for invoking getStacks. + */ +export interface GetStacksArgs { + administrative?: inputs.GetStacksAdministrative; + branch?: inputs.GetStacksBranch; + /** + * Require stacks to be on one of the commits + */ + commit?: inputs.GetStacksCommit; + labels?: inputs.GetStacksLabel[]; + /** + * Require stacks to be locked + */ + locked?: inputs.GetStacksLocked; + name?: inputs.GetStacksName; + projectRoot?: inputs.GetStacksProjectRoot; + repository?: inputs.GetStacksRepository; + /** + * Require stacks to have one of the states + */ + state?: inputs.GetStacksState; + /** + * Require stacks to use one of the IaC vendors + */ + vendor?: inputs.GetStacksVendor; + /** + * Require stacks to use one of the worker pools + */ + workerPool?: inputs.GetStacksWorkerPool; +} + +/** + * A collection of values returned by getStacks. + */ +export interface GetStacksResult { + /** + * Require stacks to be administrative or not + */ + readonly administrative?: outputs.GetStacksAdministrative; + /** + * Require stacks to be on one of the branches + */ + readonly branch?: outputs.GetStacksBranch; + /** + * Require stacks to be on one of the commits + */ + readonly commit?: outputs.GetStacksCommit; + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + /** + * Require stacks to have one of the labels + */ + readonly labels?: outputs.GetStacksLabel[]; + /** + * Require stacks to be locked + */ + readonly locked?: outputs.GetStacksLocked; + /** + * Require stacks to have one of the names + */ + readonly name?: outputs.GetStacksName; + /** + * Require stacks to be in one of the project roots + */ + readonly projectRoot?: outputs.GetStacksProjectRoot; + /** + * Require stacks to be in one of the repositories + */ + readonly repository?: outputs.GetStacksRepository; + /** + * List of stacks matching the predicates + */ + readonly stacks: outputs.GetStacksStack[]; + /** + * Require stacks to have one of the states + */ + readonly state?: outputs.GetStacksState; + /** + * Require stacks to use one of the IaC vendors + */ + readonly vendor?: outputs.GetStacksVendor; + /** + * Require stacks to use one of the worker pools + */ + readonly workerPool?: outputs.GetStacksWorkerPool; +} +/** + * `spacelift.getStacks` represents all the stacks in the Spacelift account visible to the API user, matching predicates. + */ +export function getStacksOutput(args?: GetStacksOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(args).apply((a: any) => getStacks(a, opts)) +} + +/** + * A collection of arguments for invoking getStacks. + */ +export interface GetStacksOutputArgs { + administrative?: pulumi.Input; + branch?: pulumi.Input; + /** + * Require stacks to be on one of the commits + */ + commit?: pulumi.Input; + labels?: pulumi.Input[]>; + /** + * Require stacks to be locked + */ + locked?: pulumi.Input; + name?: pulumi.Input; + projectRoot?: pulumi.Input; + repository?: pulumi.Input; + /** + * Require stacks to have one of the states + */ + state?: pulumi.Input; + /** + * Require stacks to use one of the IaC vendors + */ + vendor?: pulumi.Input; + /** + * Require stacks to use one of the worker pools + */ + workerPool?: pulumi.Input; +} diff --git a/sdk/nodejs/getVcsAgentPool.ts b/sdk/nodejs/getVcsAgentPool.ts index 3c0e2c4..3d9faf2 100644 --- a/sdk/nodejs/getVcsAgentPool.ts +++ b/sdk/nodejs/getVcsAgentPool.ts @@ -6,24 +6,10 @@ import * as utilities from "./utilities"; /** * `spacelift.VcsAgentPool` represents a Spacelift **VCS agent pool** - a logical group of proxies allowing Spacelift to access private VCS installations - * - * ## Example Usage - * - * ```typescript - * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; - * - * const ghe = pulumi.output(spacelift.getContext({ - * vcsAgentPoolId: "01FMQWT1P8BKRZF364SWVF9XYG", - * })); - * ``` */ export function getVcsAgentPool(args: GetVcsAgentPoolArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getVcsAgentPool:getVcsAgentPool", { "vcsAgentPoolId": args.vcsAgentPoolId, }, opts); @@ -60,9 +46,11 @@ export interface GetVcsAgentPoolResult { */ readonly vcsAgentPoolId: string; } - +/** + * `spacelift.VcsAgentPool` represents a Spacelift **VCS agent pool** - a logical group of proxies allowing Spacelift to access private VCS installations + */ export function getVcsAgentPoolOutput(args: GetVcsAgentPoolOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getVcsAgentPool(a, opts)) + return pulumi.output(args).apply((a: any) => getVcsAgentPool(a, opts)) } /** diff --git a/sdk/nodejs/getVcsAgentPools.ts b/sdk/nodejs/getVcsAgentPools.ts index ac18f58..5802387 100644 --- a/sdk/nodejs/getVcsAgentPools.ts +++ b/sdk/nodejs/getVcsAgentPools.ts @@ -15,15 +15,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const vcs_agent_pools = pulumi.output(spacelift.getVcsAgentPools()); + * const vcs-agent-pools = spacelift.getVcsAgentPools({}); * ``` */ export function getVcsAgentPools(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getVcsAgentPools:getVcsAgentPools", { }, opts); } @@ -38,3 +35,18 @@ export interface GetVcsAgentPoolsResult { readonly id: string; readonly vcsAgentPools: outputs.GetVcsAgentPoolsVcsAgentPool[]; } +/** + * `spacelift.getVcsAgentPools` represents the VCS agent pools assigned to the Spacelift account. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const vcs-agent-pools = spacelift.getVcsAgentPools({}); + * ``` + */ +export function getVcsAgentPoolsOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getVcsAgentPools(opts)) +} diff --git a/sdk/nodejs/getWebhook.ts b/sdk/nodejs/getWebhook.ts index c9d6a22..f28aa7c 100644 --- a/sdk/nodejs/getWebhook.ts +++ b/sdk/nodejs/getWebhook.ts @@ -19,11 +19,8 @@ import * as utilities from "./utilities"; * ``` */ export function getWebhook(args: GetWebhookArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getWebhook:getWebhook", { "moduleId": args.moduleId, "stackId": args.stackId, @@ -82,9 +79,22 @@ export interface GetWebhookResult { */ readonly webhookId: string; } - +/** + * `spacelift.Webhook` represents a webhook endpoint to which Spacelift sends the POST request about run state changes. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const webhook = spacelift.getWebhook({ + * webhookId: spacelift_webhook.webhook.id, + * }); + * ``` + */ export function getWebhookOutput(args: GetWebhookOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getWebhook(a, opts)) + return pulumi.output(args).apply((a: any) => getWebhook(a, opts)) } /** diff --git a/sdk/nodejs/getWorkerPool.ts b/sdk/nodejs/getWorkerPool.ts index b9623ab..e02ceeb 100644 --- a/sdk/nodejs/getWorkerPool.ts +++ b/sdk/nodejs/getWorkerPool.ts @@ -13,17 +13,14 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const k8s_core = pulumi.output(spacelift.getWorkerPool({ - * workerPoolId: "k8s-core", - * })); + * const k8s-core = spacelift.getWorkerPool({ + * workerPoolId: "01G1KTZ4BA86RBN3XNN3YK9EWT", + * }); * ``` */ export function getWorkerPool(args: GetWorkerPoolArgs, opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getWorkerPool:getWorkerPool", { "workerPoolId": args.workerPoolId, }, opts); @@ -69,9 +66,22 @@ export interface GetWorkerPoolResult { */ readonly workerPoolId: string; } - +/** + * `spacelift.WorkerPool` represents a worker pool assigned to the Spacelift account. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const k8s-core = spacelift.getWorkerPool({ + * workerPoolId: "01G1KTZ4BA86RBN3XNN3YK9EWT", + * }); + * ``` + */ export function getWorkerPoolOutput(args: GetWorkerPoolOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output { - return pulumi.output(args).apply(a => getWorkerPool(a, opts)) + return pulumi.output(args).apply((a: any) => getWorkerPool(a, opts)) } /** diff --git a/sdk/nodejs/getWorkerPools.ts b/sdk/nodejs/getWorkerPools.ts index 48a33d8..56e5417 100644 --- a/sdk/nodejs/getWorkerPools.ts +++ b/sdk/nodejs/getWorkerPools.ts @@ -15,15 +15,12 @@ import * as utilities from "./utilities"; * import * as pulumi from "@pulumi/pulumi"; * import * as spacelift from "@pulumi/spacelift"; * - * const worker_pools = pulumi.output(spacelift.getWorkerPools()); + * const worker-pools = spacelift.getWorkerPools({}); * ``` */ export function getWorkerPools(opts?: pulumi.InvokeOptions): Promise { - if (!opts) { - opts = {} - } - opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); return pulumi.runtime.invoke("spacelift:index/getWorkerPools:getWorkerPools", { }, opts); } @@ -38,3 +35,18 @@ export interface GetWorkerPoolsResult { readonly id: string; readonly workerPools: outputs.GetWorkerPoolsWorkerPool[]; } +/** + * `spacelift.getWorkerPools` represents the worker pools assigned to the Spacelift account. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@pulumi/spacelift"; + * + * const worker-pools = spacelift.getWorkerPools({}); + * ``` + */ +export function getWorkerPoolsOutput(opts?: pulumi.InvokeOptions): pulumi.Output { + return pulumi.output(getWorkerPools(opts)) +} diff --git a/sdk/nodejs/idpGroupMapping.ts b/sdk/nodejs/idpGroupMapping.ts new file mode 100644 index 0000000..ea3b436 --- /dev/null +++ b/sdk/nodejs/idpGroupMapping.ts @@ -0,0 +1,112 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * `spacelift.IdpGroupMapping` represents a mapping (binding) between a user group (as provided by IdP) and a Spacelift User Management Policy. If you assign permissions (a Policy) to a user group, all users in the group will have those permissions unless the user's permissions are higher than the group's permissions. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const test = new spacelift.IdpGroupMapping("test", {policies: [ + * { + * role: "ADMIN", + * spaceId: "root", + * }, + * { + * role: "ADMIN", + * spaceId: "legacy", + * }, + * ]}); + * ``` + */ +export class IdpGroupMapping extends pulumi.CustomResource { + /** + * Get an existing IdpGroupMapping resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: IdpGroupMappingState, opts?: pulumi.CustomResourceOptions): IdpGroupMapping { + return new IdpGroupMapping(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/idpGroupMapping:IdpGroupMapping'; + + /** + * Returns true if the given object is an instance of IdpGroupMapping. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is IdpGroupMapping { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === IdpGroupMapping.__pulumiType; + } + + /** + * Name of the user group - should be unique in one account + */ + public readonly name!: pulumi.Output; + public readonly policies!: pulumi.Output; + + /** + * Create a IdpGroupMapping resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: IdpGroupMappingArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: IdpGroupMappingArgs | IdpGroupMappingState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as IdpGroupMappingState | undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["policies"] = state ? state.policies : undefined; + } else { + const args = argsOrState as IdpGroupMappingArgs | undefined; + if ((!args || args.policies === undefined) && !opts.urn) { + throw new Error("Missing required property 'policies'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["policies"] = args ? args.policies : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(IdpGroupMapping.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering IdpGroupMapping resources. + */ +export interface IdpGroupMappingState { + /** + * Name of the user group - should be unique in one account + */ + name?: pulumi.Input; + policies?: pulumi.Input[]>; +} + +/** + * The set of arguments for constructing a IdpGroupMapping resource. + */ +export interface IdpGroupMappingArgs { + /** + * Name of the user group - should be unique in one account + */ + name?: pulumi.Input; + policies: pulumi.Input[]>; +} diff --git a/sdk/nodejs/index.ts b/sdk/nodejs/index.ts index 49efdaa..530c362 100644 --- a/sdk/nodejs/index.ts +++ b/sdk/nodejs/index.ts @@ -8,274 +8,399 @@ import * as utilities from "./utilities"; export { AwsIntegrationArgs, AwsIntegrationState } from "./awsIntegration"; export type AwsIntegration = import("./awsIntegration").AwsIntegration; export const AwsIntegration: typeof import("./awsIntegration").AwsIntegration = null as any; +utilities.lazyLoad(exports, ["AwsIntegration"], () => require("./awsIntegration")); export { AwsIntegrationAttachmentArgs, AwsIntegrationAttachmentState } from "./awsIntegrationAttachment"; export type AwsIntegrationAttachment = import("./awsIntegrationAttachment").AwsIntegrationAttachment; export const AwsIntegrationAttachment: typeof import("./awsIntegrationAttachment").AwsIntegrationAttachment = null as any; +utilities.lazyLoad(exports, ["AwsIntegrationAttachment"], () => require("./awsIntegrationAttachment")); export { AwsRoleArgs, AwsRoleState } from "./awsRole"; export type AwsRole = import("./awsRole").AwsRole; export const AwsRole: typeof import("./awsRole").AwsRole = null as any; +utilities.lazyLoad(exports, ["AwsRole"], () => require("./awsRole")); export { AzureIntegrationArgs, AzureIntegrationState } from "./azureIntegration"; export type AzureIntegration = import("./azureIntegration").AzureIntegration; export const AzureIntegration: typeof import("./azureIntegration").AzureIntegration = null as any; +utilities.lazyLoad(exports, ["AzureIntegration"], () => require("./azureIntegration")); export { AzureIntegrationAttachmentArgs, AzureIntegrationAttachmentState } from "./azureIntegrationAttachment"; export type AzureIntegrationAttachment = import("./azureIntegrationAttachment").AzureIntegrationAttachment; export const AzureIntegrationAttachment: typeof import("./azureIntegrationAttachment").AzureIntegrationAttachment = null as any; +utilities.lazyLoad(exports, ["AzureIntegrationAttachment"], () => require("./azureIntegrationAttachment")); + +export { BlueprintArgs, BlueprintState } from "./blueprint"; +export type Blueprint = import("./blueprint").Blueprint; +export const Blueprint: typeof import("./blueprint").Blueprint = null as any; +utilities.lazyLoad(exports, ["Blueprint"], () => require("./blueprint")); export { ContextArgs, ContextState } from "./context"; export type Context = import("./context").Context; export const Context: typeof import("./context").Context = null as any; +utilities.lazyLoad(exports, ["Context"], () => require("./context")); export { ContextAttachmentArgs, ContextAttachmentState } from "./contextAttachment"; export type ContextAttachment = import("./contextAttachment").ContextAttachment; export const ContextAttachment: typeof import("./contextAttachment").ContextAttachment = null as any; +utilities.lazyLoad(exports, ["ContextAttachment"], () => require("./contextAttachment")); export { DriftDetectionArgs, DriftDetectionState } from "./driftDetection"; export type DriftDetection = import("./driftDetection").DriftDetection; export const DriftDetection: typeof import("./driftDetection").DriftDetection = null as any; +utilities.lazyLoad(exports, ["DriftDetection"], () => require("./driftDetection")); export { EnvironmentVariableArgs, EnvironmentVariableState } from "./environmentVariable"; export type EnvironmentVariable = import("./environmentVariable").EnvironmentVariable; export const EnvironmentVariable: typeof import("./environmentVariable").EnvironmentVariable = null as any; +utilities.lazyLoad(exports, ["EnvironmentVariable"], () => require("./environmentVariable")); export { GcpServiceAccountArgs, GcpServiceAccountState } from "./gcpServiceAccount"; export type GcpServiceAccount = import("./gcpServiceAccount").GcpServiceAccount; export const GcpServiceAccount: typeof import("./gcpServiceAccount").GcpServiceAccount = null as any; +utilities.lazyLoad(exports, ["GcpServiceAccount"], () => require("./gcpServiceAccount")); export { GetAccountResult } from "./getAccount"; export const getAccount: typeof import("./getAccount").getAccount = null as any; +export const getAccountOutput: typeof import("./getAccount").getAccountOutput = null as any; +utilities.lazyLoad(exports, ["getAccount","getAccountOutput"], () => require("./getAccount")); export { GetAwsIntegrationArgs, GetAwsIntegrationResult, GetAwsIntegrationOutputArgs } from "./getAwsIntegration"; export const getAwsIntegration: typeof import("./getAwsIntegration").getAwsIntegration = null as any; export const getAwsIntegrationOutput: typeof import("./getAwsIntegration").getAwsIntegrationOutput = null as any; +utilities.lazyLoad(exports, ["getAwsIntegration","getAwsIntegrationOutput"], () => require("./getAwsIntegration")); export { GetAwsIntegrationAttachmentArgs, GetAwsIntegrationAttachmentResult, GetAwsIntegrationAttachmentOutputArgs } from "./getAwsIntegrationAttachment"; export const getAwsIntegrationAttachment: typeof import("./getAwsIntegrationAttachment").getAwsIntegrationAttachment = null as any; export const getAwsIntegrationAttachmentOutput: typeof import("./getAwsIntegrationAttachment").getAwsIntegrationAttachmentOutput = null as any; +utilities.lazyLoad(exports, ["getAwsIntegrationAttachment","getAwsIntegrationAttachmentOutput"], () => require("./getAwsIntegrationAttachment")); export { GetAwsIntegrationAttachmentExternalIdArgs, GetAwsIntegrationAttachmentExternalIdResult, GetAwsIntegrationAttachmentExternalIdOutputArgs } from "./getAwsIntegrationAttachmentExternalId"; export const getAwsIntegrationAttachmentExternalId: typeof import("./getAwsIntegrationAttachmentExternalId").getAwsIntegrationAttachmentExternalId = null as any; export const getAwsIntegrationAttachmentExternalIdOutput: typeof import("./getAwsIntegrationAttachmentExternalId").getAwsIntegrationAttachmentExternalIdOutput = null as any; +utilities.lazyLoad(exports, ["getAwsIntegrationAttachmentExternalId","getAwsIntegrationAttachmentExternalIdOutput"], () => require("./getAwsIntegrationAttachmentExternalId")); + +export { GetAwsIntegrationsResult } from "./getAwsIntegrations"; +export const getAwsIntegrations: typeof import("./getAwsIntegrations").getAwsIntegrations = null as any; +export const getAwsIntegrationsOutput: typeof import("./getAwsIntegrations").getAwsIntegrationsOutput = null as any; +utilities.lazyLoad(exports, ["getAwsIntegrations","getAwsIntegrationsOutput"], () => require("./getAwsIntegrations")); export { GetAwsRoleArgs, GetAwsRoleResult, GetAwsRoleOutputArgs } from "./getAwsRole"; export const getAwsRole: typeof import("./getAwsRole").getAwsRole = null as any; export const getAwsRoleOutput: typeof import("./getAwsRole").getAwsRoleOutput = null as any; +utilities.lazyLoad(exports, ["getAwsRole","getAwsRoleOutput"], () => require("./getAwsRole")); export { GetAzureDevopsIntegrationResult } from "./getAzureDevopsIntegration"; export const getAzureDevopsIntegration: typeof import("./getAzureDevopsIntegration").getAzureDevopsIntegration = null as any; +export const getAzureDevopsIntegrationOutput: typeof import("./getAzureDevopsIntegration").getAzureDevopsIntegrationOutput = null as any; +utilities.lazyLoad(exports, ["getAzureDevopsIntegration","getAzureDevopsIntegrationOutput"], () => require("./getAzureDevopsIntegration")); export { GetAzureIntegrationArgs, GetAzureIntegrationResult, GetAzureIntegrationOutputArgs } from "./getAzureIntegration"; export const getAzureIntegration: typeof import("./getAzureIntegration").getAzureIntegration = null as any; export const getAzureIntegrationOutput: typeof import("./getAzureIntegration").getAzureIntegrationOutput = null as any; +utilities.lazyLoad(exports, ["getAzureIntegration","getAzureIntegrationOutput"], () => require("./getAzureIntegration")); export { GetAzureIntegrationAttachmentArgs, GetAzureIntegrationAttachmentResult, GetAzureIntegrationAttachmentOutputArgs } from "./getAzureIntegrationAttachment"; export const getAzureIntegrationAttachment: typeof import("./getAzureIntegrationAttachment").getAzureIntegrationAttachment = null as any; export const getAzureIntegrationAttachmentOutput: typeof import("./getAzureIntegrationAttachment").getAzureIntegrationAttachmentOutput = null as any; +utilities.lazyLoad(exports, ["getAzureIntegrationAttachment","getAzureIntegrationAttachmentOutput"], () => require("./getAzureIntegrationAttachment")); + +export { GetAzureIntegrationsResult } from "./getAzureIntegrations"; +export const getAzureIntegrations: typeof import("./getAzureIntegrations").getAzureIntegrations = null as any; +export const getAzureIntegrationsOutput: typeof import("./getAzureIntegrations").getAzureIntegrationsOutput = null as any; +utilities.lazyLoad(exports, ["getAzureIntegrations","getAzureIntegrationsOutput"], () => require("./getAzureIntegrations")); export { GetBitbucketCloudIntegrationResult } from "./getBitbucketCloudIntegration"; export const getBitbucketCloudIntegration: typeof import("./getBitbucketCloudIntegration").getBitbucketCloudIntegration = null as any; +export const getBitbucketCloudIntegrationOutput: typeof import("./getBitbucketCloudIntegration").getBitbucketCloudIntegrationOutput = null as any; +utilities.lazyLoad(exports, ["getBitbucketCloudIntegration","getBitbucketCloudIntegrationOutput"], () => require("./getBitbucketCloudIntegration")); export { GetBitbucketDatacenterIntegrationResult } from "./getBitbucketDatacenterIntegration"; export const getBitbucketDatacenterIntegration: typeof import("./getBitbucketDatacenterIntegration").getBitbucketDatacenterIntegration = null as any; +export const getBitbucketDatacenterIntegrationOutput: typeof import("./getBitbucketDatacenterIntegration").getBitbucketDatacenterIntegrationOutput = null as any; +utilities.lazyLoad(exports, ["getBitbucketDatacenterIntegration","getBitbucketDatacenterIntegrationOutput"], () => require("./getBitbucketDatacenterIntegration")); export { GetContextArgs, GetContextResult, GetContextOutputArgs } from "./getContext"; export const getContext: typeof import("./getContext").getContext = null as any; export const getContextOutput: typeof import("./getContext").getContextOutput = null as any; +utilities.lazyLoad(exports, ["getContext","getContextOutput"], () => require("./getContext")); export { GetContextAttachmentArgs, GetContextAttachmentResult, GetContextAttachmentOutputArgs } from "./getContextAttachment"; export const getContextAttachment: typeof import("./getContextAttachment").getContextAttachment = null as any; export const getContextAttachmentOutput: typeof import("./getContextAttachment").getContextAttachmentOutput = null as any; +utilities.lazyLoad(exports, ["getContextAttachment","getContextAttachmentOutput"], () => require("./getContextAttachment")); + +export { GetContextsArgs, GetContextsResult, GetContextsOutputArgs } from "./getContexts"; +export const getContexts: typeof import("./getContexts").getContexts = null as any; +export const getContextsOutput: typeof import("./getContexts").getContextsOutput = null as any; +utilities.lazyLoad(exports, ["getContexts","getContextsOutput"], () => require("./getContexts")); + +export { GetCurrentSpaceResult } from "./getCurrentSpace"; +export const getCurrentSpace: typeof import("./getCurrentSpace").getCurrentSpace = null as any; +export const getCurrentSpaceOutput: typeof import("./getCurrentSpace").getCurrentSpaceOutput = null as any; +utilities.lazyLoad(exports, ["getCurrentSpace","getCurrentSpaceOutput"], () => require("./getCurrentSpace")); export { GetCurrentStackResult } from "./getCurrentStack"; export const getCurrentStack: typeof import("./getCurrentStack").getCurrentStack = null as any; +export const getCurrentStackOutput: typeof import("./getCurrentStack").getCurrentStackOutput = null as any; +utilities.lazyLoad(exports, ["getCurrentStack","getCurrentStackOutput"], () => require("./getCurrentStack")); export { GetDriftDetectionArgs, GetDriftDetectionResult, GetDriftDetectionOutputArgs } from "./getDriftDetection"; export const getDriftDetection: typeof import("./getDriftDetection").getDriftDetection = null as any; export const getDriftDetectionOutput: typeof import("./getDriftDetection").getDriftDetectionOutput = null as any; +utilities.lazyLoad(exports, ["getDriftDetection","getDriftDetectionOutput"], () => require("./getDriftDetection")); export { GetEnvironmentVariableArgs, GetEnvironmentVariableResult, GetEnvironmentVariableOutputArgs } from "./getEnvironmentVariable"; export const getEnvironmentVariable: typeof import("./getEnvironmentVariable").getEnvironmentVariable = null as any; export const getEnvironmentVariableOutput: typeof import("./getEnvironmentVariable").getEnvironmentVariableOutput = null as any; +utilities.lazyLoad(exports, ["getEnvironmentVariable","getEnvironmentVariableOutput"], () => require("./getEnvironmentVariable")); export { GetGcpServiceAccountArgs, GetGcpServiceAccountResult, GetGcpServiceAccountOutputArgs } from "./getGcpServiceAccount"; export const getGcpServiceAccount: typeof import("./getGcpServiceAccount").getGcpServiceAccount = null as any; export const getGcpServiceAccountOutput: typeof import("./getGcpServiceAccount").getGcpServiceAccountOutput = null as any; +utilities.lazyLoad(exports, ["getGcpServiceAccount","getGcpServiceAccountOutput"], () => require("./getGcpServiceAccount")); export { GetGithubEnterpriseIntegrationResult } from "./getGithubEnterpriseIntegration"; export const getGithubEnterpriseIntegration: typeof import("./getGithubEnterpriseIntegration").getGithubEnterpriseIntegration = null as any; +export const getGithubEnterpriseIntegrationOutput: typeof import("./getGithubEnterpriseIntegration").getGithubEnterpriseIntegrationOutput = null as any; +utilities.lazyLoad(exports, ["getGithubEnterpriseIntegration","getGithubEnterpriseIntegrationOutput"], () => require("./getGithubEnterpriseIntegration")); export { GetGitlabIntegrationResult } from "./getGitlabIntegration"; export const getGitlabIntegration: typeof import("./getGitlabIntegration").getGitlabIntegration = null as any; +export const getGitlabIntegrationOutput: typeof import("./getGitlabIntegration").getGitlabIntegrationOutput = null as any; +utilities.lazyLoad(exports, ["getGitlabIntegration","getGitlabIntegrationOutput"], () => require("./getGitlabIntegration")); + +export { GetGitlabWebhookEndpointResult } from "./getGitlabWebhookEndpoint"; +export const getGitlabWebhookEndpoint: typeof import("./getGitlabWebhookEndpoint").getGitlabWebhookEndpoint = null as any; +export const getGitlabWebhookEndpointOutput: typeof import("./getGitlabWebhookEndpoint").getGitlabWebhookEndpointOutput = null as any; +utilities.lazyLoad(exports, ["getGitlabWebhookEndpoint","getGitlabWebhookEndpointOutput"], () => require("./getGitlabWebhookEndpoint")); export { GetIPsResult } from "./getIPs"; export const getIPs: typeof import("./getIPs").getIPs = null as any; +export const getIPsOutput: typeof import("./getIPs").getIPsOutput = null as any; +utilities.lazyLoad(exports, ["getIPs","getIPsOutput"], () => require("./getIPs")); export { GetModuleArgs, GetModuleResult, GetModuleOutputArgs } from "./getModule"; export const getModule: typeof import("./getModule").getModule = null as any; export const getModuleOutput: typeof import("./getModule").getModuleOutput = null as any; +utilities.lazyLoad(exports, ["getModule","getModuleOutput"], () => require("./getModule")); export { GetMountedfileArgs, GetMountedfileResult, GetMountedfileOutputArgs } from "./getMountedfile"; export const getMountedfile: typeof import("./getMountedfile").getMountedfile = null as any; export const getMountedfileOutput: typeof import("./getMountedfile").getMountedfileOutput = null as any; +utilities.lazyLoad(exports, ["getMountedfile","getMountedfileOutput"], () => require("./getMountedfile")); + +export { GetNamedWebhookArgs, GetNamedWebhookResult, GetNamedWebhookOutputArgs } from "./getNamedWebhook"; +export const getNamedWebhook: typeof import("./getNamedWebhook").getNamedWebhook = null as any; +export const getNamedWebhookOutput: typeof import("./getNamedWebhook").getNamedWebhookOutput = null as any; +utilities.lazyLoad(exports, ["getNamedWebhook","getNamedWebhookOutput"], () => require("./getNamedWebhook")); export { GetPoliciesArgs, GetPoliciesResult, GetPoliciesOutputArgs } from "./getPolicies"; export const getPolicies: typeof import("./getPolicies").getPolicies = null as any; export const getPoliciesOutput: typeof import("./getPolicies").getPoliciesOutput = null as any; +utilities.lazyLoad(exports, ["getPolicies","getPoliciesOutput"], () => require("./getPolicies")); export { GetPolicyArgs, GetPolicyResult, GetPolicyOutputArgs } from "./getPolicy"; export const getPolicy: typeof import("./getPolicy").getPolicy = null as any; export const getPolicyOutput: typeof import("./getPolicy").getPolicyOutput = null as any; +utilities.lazyLoad(exports, ["getPolicy","getPolicyOutput"], () => require("./getPolicy")); + +export { GetScheduledDeleteStackArgs, GetScheduledDeleteStackResult, GetScheduledDeleteStackOutputArgs } from "./getScheduledDeleteStack"; +export const getScheduledDeleteStack: typeof import("./getScheduledDeleteStack").getScheduledDeleteStack = null as any; +export const getScheduledDeleteStackOutput: typeof import("./getScheduledDeleteStack").getScheduledDeleteStackOutput = null as any; +utilities.lazyLoad(exports, ["getScheduledDeleteStack","getScheduledDeleteStackOutput"], () => require("./getScheduledDeleteStack")); + +export { GetScheduledTaskArgs, GetScheduledTaskResult, GetScheduledTaskOutputArgs } from "./getScheduledTask"; +export const getScheduledTask: typeof import("./getScheduledTask").getScheduledTask = null as any; +export const getScheduledTaskOutput: typeof import("./getScheduledTask").getScheduledTaskOutput = null as any; +utilities.lazyLoad(exports, ["getScheduledTask","getScheduledTaskOutput"], () => require("./getScheduledTask")); export { GetSpaceArgs, GetSpaceResult, GetSpaceOutputArgs } from "./getSpace"; export const getSpace: typeof import("./getSpace").getSpace = null as any; export const getSpaceOutput: typeof import("./getSpace").getSpaceOutput = null as any; +utilities.lazyLoad(exports, ["getSpace","getSpaceOutput"], () => require("./getSpace")); + +export { GetSpaceByPathArgs, GetSpaceByPathResult, GetSpaceByPathOutputArgs } from "./getSpaceByPath"; +export const getSpaceByPath: typeof import("./getSpaceByPath").getSpaceByPath = null as any; +export const getSpaceByPathOutput: typeof import("./getSpaceByPath").getSpaceByPathOutput = null as any; +utilities.lazyLoad(exports, ["getSpaceByPath","getSpaceByPathOutput"], () => require("./getSpaceByPath")); + +export { GetSpacesResult } from "./getSpaces"; +export const getSpaces: typeof import("./getSpaces").getSpaces = null as any; +export const getSpacesOutput: typeof import("./getSpaces").getSpacesOutput = null as any; +utilities.lazyLoad(exports, ["getSpaces","getSpacesOutput"], () => require("./getSpaces")); export { GetStackArgs, GetStackResult, GetStackOutputArgs } from "./getStack"; export const getStack: typeof import("./getStack").getStack = null as any; export const getStackOutput: typeof import("./getStack").getStackOutput = null as any; +utilities.lazyLoad(exports, ["getStack","getStackOutput"], () => require("./getStack")); export { GetStackAwsRoleArgs, GetStackAwsRoleResult, GetStackAwsRoleOutputArgs } from "./getStackAwsRole"; export const getStackAwsRole: typeof import("./getStackAwsRole").getStackAwsRole = null as any; export const getStackAwsRoleOutput: typeof import("./getStackAwsRole").getStackAwsRoleOutput = null as any; +utilities.lazyLoad(exports, ["getStackAwsRole","getStackAwsRoleOutput"], () => require("./getStackAwsRole")); export { GetStackGcpServiceAccountArgs, GetStackGcpServiceAccountResult, GetStackGcpServiceAccountOutputArgs } from "./getStackGcpServiceAccount"; export const getStackGcpServiceAccount: typeof import("./getStackGcpServiceAccount").getStackGcpServiceAccount = null as any; export const getStackGcpServiceAccountOutput: typeof import("./getStackGcpServiceAccount").getStackGcpServiceAccountOutput = null as any; +utilities.lazyLoad(exports, ["getStackGcpServiceAccount","getStackGcpServiceAccountOutput"], () => require("./getStackGcpServiceAccount")); + +export { GetStacksArgs, GetStacksResult, GetStacksOutputArgs } from "./getStacks"; +export const getStacks: typeof import("./getStacks").getStacks = null as any; +export const getStacksOutput: typeof import("./getStacks").getStacksOutput = null as any; +utilities.lazyLoad(exports, ["getStacks","getStacksOutput"], () => require("./getStacks")); export { GetVcsAgentPoolArgs, GetVcsAgentPoolResult, GetVcsAgentPoolOutputArgs } from "./getVcsAgentPool"; export const getVcsAgentPool: typeof import("./getVcsAgentPool").getVcsAgentPool = null as any; export const getVcsAgentPoolOutput: typeof import("./getVcsAgentPool").getVcsAgentPoolOutput = null as any; +utilities.lazyLoad(exports, ["getVcsAgentPool","getVcsAgentPoolOutput"], () => require("./getVcsAgentPool")); export { GetVcsAgentPoolsResult } from "./getVcsAgentPools"; export const getVcsAgentPools: typeof import("./getVcsAgentPools").getVcsAgentPools = null as any; +export const getVcsAgentPoolsOutput: typeof import("./getVcsAgentPools").getVcsAgentPoolsOutput = null as any; +utilities.lazyLoad(exports, ["getVcsAgentPools","getVcsAgentPoolsOutput"], () => require("./getVcsAgentPools")); export { GetWebhookArgs, GetWebhookResult, GetWebhookOutputArgs } from "./getWebhook"; export const getWebhook: typeof import("./getWebhook").getWebhook = null as any; export const getWebhookOutput: typeof import("./getWebhook").getWebhookOutput = null as any; +utilities.lazyLoad(exports, ["getWebhook","getWebhookOutput"], () => require("./getWebhook")); export { GetWorkerPoolArgs, GetWorkerPoolResult, GetWorkerPoolOutputArgs } from "./getWorkerPool"; export const getWorkerPool: typeof import("./getWorkerPool").getWorkerPool = null as any; export const getWorkerPoolOutput: typeof import("./getWorkerPool").getWorkerPoolOutput = null as any; +utilities.lazyLoad(exports, ["getWorkerPool","getWorkerPoolOutput"], () => require("./getWorkerPool")); export { GetWorkerPoolsResult } from "./getWorkerPools"; export const getWorkerPools: typeof import("./getWorkerPools").getWorkerPools = null as any; +export const getWorkerPoolsOutput: typeof import("./getWorkerPools").getWorkerPoolsOutput = null as any; +utilities.lazyLoad(exports, ["getWorkerPools","getWorkerPoolsOutput"], () => require("./getWorkerPools")); + +export { IdpGroupMappingArgs, IdpGroupMappingState } from "./idpGroupMapping"; +export type IdpGroupMapping = import("./idpGroupMapping").IdpGroupMapping; +export const IdpGroupMapping: typeof import("./idpGroupMapping").IdpGroupMapping = null as any; +utilities.lazyLoad(exports, ["IdpGroupMapping"], () => require("./idpGroupMapping")); export { ModuleArgs, ModuleState } from "./module"; export type Module = import("./module").Module; export const Module: typeof import("./module").Module = null as any; +utilities.lazyLoad(exports, ["Module"], () => require("./module")); export { MountedfileArgs, MountedfileState } from "./mountedfile"; export type Mountedfile = import("./mountedfile").Mountedfile; export const Mountedfile: typeof import("./mountedfile").Mountedfile = null as any; +utilities.lazyLoad(exports, ["Mountedfile"], () => require("./mountedfile")); + +export { NamedWebhookArgs, NamedWebhookState } from "./namedWebhook"; +export type NamedWebhook = import("./namedWebhook").NamedWebhook; +export const NamedWebhook: typeof import("./namedWebhook").NamedWebhook = null as any; +utilities.lazyLoad(exports, ["NamedWebhook"], () => require("./namedWebhook")); + +export { NamedWebhookSecretHeaderArgs, NamedWebhookSecretHeaderState } from "./namedWebhookSecretHeader"; +export type NamedWebhookSecretHeader = import("./namedWebhookSecretHeader").NamedWebhookSecretHeader; +export const NamedWebhookSecretHeader: typeof import("./namedWebhookSecretHeader").NamedWebhookSecretHeader = null as any; +utilities.lazyLoad(exports, ["NamedWebhookSecretHeader"], () => require("./namedWebhookSecretHeader")); export { PolicyArgs, PolicyState } from "./policy"; export type Policy = import("./policy").Policy; export const Policy: typeof import("./policy").Policy = null as any; +utilities.lazyLoad(exports, ["Policy"], () => require("./policy")); export { PolicyAttachmentArgs, PolicyAttachmentState } from "./policyAttachment"; export type PolicyAttachment = import("./policyAttachment").PolicyAttachment; export const PolicyAttachment: typeof import("./policyAttachment").PolicyAttachment = null as any; +utilities.lazyLoad(exports, ["PolicyAttachment"], () => require("./policyAttachment")); export { ProviderArgs } from "./provider"; export type Provider = import("./provider").Provider; export const Provider: typeof import("./provider").Provider = null as any; +utilities.lazyLoad(exports, ["Provider"], () => require("./provider")); export { RunArgs, RunState } from "./run"; export type Run = import("./run").Run; export const Run: typeof import("./run").Run = null as any; +utilities.lazyLoad(exports, ["Run"], () => require("./run")); + +export { ScheduledDeleteTaskArgs, ScheduledDeleteTaskState } from "./scheduledDeleteTask"; +export type ScheduledDeleteTask = import("./scheduledDeleteTask").ScheduledDeleteTask; +export const ScheduledDeleteTask: typeof import("./scheduledDeleteTask").ScheduledDeleteTask = null as any; +utilities.lazyLoad(exports, ["ScheduledDeleteTask"], () => require("./scheduledDeleteTask")); + +export { ScheduledTaskArgs, ScheduledTaskState } from "./scheduledTask"; +export type ScheduledTask = import("./scheduledTask").ScheduledTask; +export const ScheduledTask: typeof import("./scheduledTask").ScheduledTask = null as any; +utilities.lazyLoad(exports, ["ScheduledTask"], () => require("./scheduledTask")); export { SpaceArgs, SpaceState } from "./space"; export type Space = import("./space").Space; export const Space: typeof import("./space").Space = null as any; +utilities.lazyLoad(exports, ["Space"], () => require("./space")); export { StackArgs, StackState } from "./stack"; export type Stack = import("./stack").Stack; export const Stack: typeof import("./stack").Stack = null as any; +utilities.lazyLoad(exports, ["Stack"], () => require("./stack")); + +export { StackActivatorArgs, StackActivatorState } from "./stackActivator"; +export type StackActivator = import("./stackActivator").StackActivator; +export const StackActivator: typeof import("./stackActivator").StackActivator = null as any; +utilities.lazyLoad(exports, ["StackActivator"], () => require("./stackActivator")); export { StackAwsRoleArgs, StackAwsRoleState } from "./stackAwsRole"; export type StackAwsRole = import("./stackAwsRole").StackAwsRole; export const StackAwsRole: typeof import("./stackAwsRole").StackAwsRole = null as any; +utilities.lazyLoad(exports, ["StackAwsRole"], () => require("./stackAwsRole")); + +export { StackDependencyArgs, StackDependencyState } from "./stackDependency"; +export type StackDependency = import("./stackDependency").StackDependency; +export const StackDependency: typeof import("./stackDependency").StackDependency = null as any; +utilities.lazyLoad(exports, ["StackDependency"], () => require("./stackDependency")); + +export { StackDependencyReferenceArgs, StackDependencyReferenceState } from "./stackDependencyReference"; +export type StackDependencyReference = import("./stackDependencyReference").StackDependencyReference; +export const StackDependencyReference: typeof import("./stackDependencyReference").StackDependencyReference = null as any; +utilities.lazyLoad(exports, ["StackDependencyReference"], () => require("./stackDependencyReference")); export { StackDestructorArgs, StackDestructorState } from "./stackDestructor"; export type StackDestructor = import("./stackDestructor").StackDestructor; export const StackDestructor: typeof import("./stackDestructor").StackDestructor = null as any; +utilities.lazyLoad(exports, ["StackDestructor"], () => require("./stackDestructor")); export { StackGcpServiceAccountArgs, StackGcpServiceAccountState } from "./stackGcpServiceAccount"; export type StackGcpServiceAccount = import("./stackGcpServiceAccount").StackGcpServiceAccount; export const StackGcpServiceAccount: typeof import("./stackGcpServiceAccount").StackGcpServiceAccount = null as any; +utilities.lazyLoad(exports, ["StackGcpServiceAccount"], () => require("./stackGcpServiceAccount")); + +export { TerraformProviderArgs, TerraformProviderState } from "./terraformProvider"; +export type TerraformProvider = import("./terraformProvider").TerraformProvider; +export const TerraformProvider: typeof import("./terraformProvider").TerraformProvider = null as any; +utilities.lazyLoad(exports, ["TerraformProvider"], () => require("./terraformProvider")); + +export { UserArgs, UserState } from "./user"; +export type User = import("./user").User; +export const User: typeof import("./user").User = null as any; +utilities.lazyLoad(exports, ["User"], () => require("./user")); export { VcsAgentPoolArgs, VcsAgentPoolState } from "./vcsAgentPool"; export type VcsAgentPool = import("./vcsAgentPool").VcsAgentPool; export const VcsAgentPool: typeof import("./vcsAgentPool").VcsAgentPool = null as any; +utilities.lazyLoad(exports, ["VcsAgentPool"], () => require("./vcsAgentPool")); + +export { VersionArgs, VersionState } from "./version"; +export type Version = import("./version").Version; +export const Version: typeof import("./version").Version = null as any; +utilities.lazyLoad(exports, ["Version"], () => require("./version")); export { WebhookArgs, WebhookState } from "./webhook"; export type Webhook = import("./webhook").Webhook; export const Webhook: typeof import("./webhook").Webhook = null as any; +utilities.lazyLoad(exports, ["Webhook"], () => require("./webhook")); export { WorkerPoolArgs, WorkerPoolState } from "./workerPool"; export type WorkerPool = import("./workerPool").WorkerPool; export const WorkerPool: typeof import("./workerPool").WorkerPool = null as any; - -utilities.lazyLoad(exports, ["AwsIntegration"], () => require("./awsIntegration")); -utilities.lazyLoad(exports, ["AwsIntegrationAttachment"], () => require("./awsIntegrationAttachment")); -utilities.lazyLoad(exports, ["AwsRole"], () => require("./awsRole")); -utilities.lazyLoad(exports, ["AzureIntegration"], () => require("./azureIntegration")); -utilities.lazyLoad(exports, ["AzureIntegrationAttachment"], () => require("./azureIntegrationAttachment")); -utilities.lazyLoad(exports, ["Context"], () => require("./context")); -utilities.lazyLoad(exports, ["ContextAttachment"], () => require("./contextAttachment")); -utilities.lazyLoad(exports, ["DriftDetection"], () => require("./driftDetection")); -utilities.lazyLoad(exports, ["EnvironmentVariable"], () => require("./environmentVariable")); -utilities.lazyLoad(exports, ["GcpServiceAccount"], () => require("./gcpServiceAccount")); -utilities.lazyLoad(exports, ["getAccount"], () => require("./getAccount")); -utilities.lazyLoad(exports, ["getAwsIntegration","getAwsIntegrationOutput"], () => require("./getAwsIntegration")); -utilities.lazyLoad(exports, ["getAwsIntegrationAttachment","getAwsIntegrationAttachmentOutput"], () => require("./getAwsIntegrationAttachment")); -utilities.lazyLoad(exports, ["getAwsIntegrationAttachmentExternalId","getAwsIntegrationAttachmentExternalIdOutput"], () => require("./getAwsIntegrationAttachmentExternalId")); -utilities.lazyLoad(exports, ["getAwsRole","getAwsRoleOutput"], () => require("./getAwsRole")); -utilities.lazyLoad(exports, ["getAzureDevopsIntegration"], () => require("./getAzureDevopsIntegration")); -utilities.lazyLoad(exports, ["getAzureIntegration","getAzureIntegrationOutput"], () => require("./getAzureIntegration")); -utilities.lazyLoad(exports, ["getAzureIntegrationAttachment","getAzureIntegrationAttachmentOutput"], () => require("./getAzureIntegrationAttachment")); -utilities.lazyLoad(exports, ["getBitbucketCloudIntegration"], () => require("./getBitbucketCloudIntegration")); -utilities.lazyLoad(exports, ["getBitbucketDatacenterIntegration"], () => require("./getBitbucketDatacenterIntegration")); -utilities.lazyLoad(exports, ["getContext","getContextOutput"], () => require("./getContext")); -utilities.lazyLoad(exports, ["getContextAttachment","getContextAttachmentOutput"], () => require("./getContextAttachment")); -utilities.lazyLoad(exports, ["getCurrentStack"], () => require("./getCurrentStack")); -utilities.lazyLoad(exports, ["getDriftDetection","getDriftDetectionOutput"], () => require("./getDriftDetection")); -utilities.lazyLoad(exports, ["getEnvironmentVariable","getEnvironmentVariableOutput"], () => require("./getEnvironmentVariable")); -utilities.lazyLoad(exports, ["getGcpServiceAccount","getGcpServiceAccountOutput"], () => require("./getGcpServiceAccount")); -utilities.lazyLoad(exports, ["getGithubEnterpriseIntegration"], () => require("./getGithubEnterpriseIntegration")); -utilities.lazyLoad(exports, ["getGitlabIntegration"], () => require("./getGitlabIntegration")); -utilities.lazyLoad(exports, ["getIPs"], () => require("./getIPs")); -utilities.lazyLoad(exports, ["getModule","getModuleOutput"], () => require("./getModule")); -utilities.lazyLoad(exports, ["getMountedfile","getMountedfileOutput"], () => require("./getMountedfile")); -utilities.lazyLoad(exports, ["getPolicies","getPoliciesOutput"], () => require("./getPolicies")); -utilities.lazyLoad(exports, ["getPolicy","getPolicyOutput"], () => require("./getPolicy")); -utilities.lazyLoad(exports, ["getSpace","getSpaceOutput"], () => require("./getSpace")); -utilities.lazyLoad(exports, ["getStack","getStackOutput"], () => require("./getStack")); -utilities.lazyLoad(exports, ["getStackAwsRole","getStackAwsRoleOutput"], () => require("./getStackAwsRole")); -utilities.lazyLoad(exports, ["getStackGcpServiceAccount","getStackGcpServiceAccountOutput"], () => require("./getStackGcpServiceAccount")); -utilities.lazyLoad(exports, ["getVcsAgentPool","getVcsAgentPoolOutput"], () => require("./getVcsAgentPool")); -utilities.lazyLoad(exports, ["getVcsAgentPools"], () => require("./getVcsAgentPools")); -utilities.lazyLoad(exports, ["getWebhook","getWebhookOutput"], () => require("./getWebhook")); -utilities.lazyLoad(exports, ["getWorkerPool","getWorkerPoolOutput"], () => require("./getWorkerPool")); -utilities.lazyLoad(exports, ["getWorkerPools"], () => require("./getWorkerPools")); -utilities.lazyLoad(exports, ["Module"], () => require("./module")); -utilities.lazyLoad(exports, ["Mountedfile"], () => require("./mountedfile")); -utilities.lazyLoad(exports, ["Policy"], () => require("./policy")); -utilities.lazyLoad(exports, ["PolicyAttachment"], () => require("./policyAttachment")); -utilities.lazyLoad(exports, ["Provider"], () => require("./provider")); -utilities.lazyLoad(exports, ["Run"], () => require("./run")); -utilities.lazyLoad(exports, ["Space"], () => require("./space")); -utilities.lazyLoad(exports, ["Stack"], () => require("./stack")); -utilities.lazyLoad(exports, ["StackAwsRole"], () => require("./stackAwsRole")); -utilities.lazyLoad(exports, ["StackDestructor"], () => require("./stackDestructor")); -utilities.lazyLoad(exports, ["StackGcpServiceAccount"], () => require("./stackGcpServiceAccount")); -utilities.lazyLoad(exports, ["VcsAgentPool"], () => require("./vcsAgentPool")); -utilities.lazyLoad(exports, ["Webhook"], () => require("./webhook")); utilities.lazyLoad(exports, ["WorkerPool"], () => require("./workerPool")); + // Export sub-modules: import * as config from "./config"; import * as types from "./types"; @@ -299,6 +424,8 @@ const _module = { return new AzureIntegration(name, undefined, { urn }) case "spacelift:index/azureIntegrationAttachment:AzureIntegrationAttachment": return new AzureIntegrationAttachment(name, undefined, { urn }) + case "spacelift:index/blueprint:Blueprint": + return new Blueprint(name, undefined, { urn }) case "spacelift:index/context:Context": return new Context(name, undefined, { urn }) case "spacelift:index/contextAttachment:ContextAttachment": @@ -309,28 +436,50 @@ const _module = { return new EnvironmentVariable(name, undefined, { urn }) case "spacelift:index/gcpServiceAccount:GcpServiceAccount": return new GcpServiceAccount(name, undefined, { urn }) + case "spacelift:index/idpGroupMapping:IdpGroupMapping": + return new IdpGroupMapping(name, undefined, { urn }) case "spacelift:index/module:Module": return new Module(name, undefined, { urn }) case "spacelift:index/mountedfile:Mountedfile": return new Mountedfile(name, undefined, { urn }) + case "spacelift:index/namedWebhook:NamedWebhook": + return new NamedWebhook(name, undefined, { urn }) + case "spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader": + return new NamedWebhookSecretHeader(name, undefined, { urn }) case "spacelift:index/policy:Policy": return new Policy(name, undefined, { urn }) case "spacelift:index/policyAttachment:PolicyAttachment": return new PolicyAttachment(name, undefined, { urn }) case "spacelift:index/run:Run": return new Run(name, undefined, { urn }) + case "spacelift:index/scheduledDeleteTask:ScheduledDeleteTask": + return new ScheduledDeleteTask(name, undefined, { urn }) + case "spacelift:index/scheduledTask:ScheduledTask": + return new ScheduledTask(name, undefined, { urn }) case "spacelift:index/space:Space": return new Space(name, undefined, { urn }) case "spacelift:index/stack:Stack": return new Stack(name, undefined, { urn }) + case "spacelift:index/stackActivator:StackActivator": + return new StackActivator(name, undefined, { urn }) case "spacelift:index/stackAwsRole:StackAwsRole": return new StackAwsRole(name, undefined, { urn }) + case "spacelift:index/stackDependency:StackDependency": + return new StackDependency(name, undefined, { urn }) + case "spacelift:index/stackDependencyReference:StackDependencyReference": + return new StackDependencyReference(name, undefined, { urn }) case "spacelift:index/stackDestructor:StackDestructor": return new StackDestructor(name, undefined, { urn }) case "spacelift:index/stackGcpServiceAccount:StackGcpServiceAccount": return new StackGcpServiceAccount(name, undefined, { urn }) + case "spacelift:index/terraformProvider:TerraformProvider": + return new TerraformProvider(name, undefined, { urn }) + case "spacelift:index/user:User": + return new User(name, undefined, { urn }) case "spacelift:index/vcsAgentPool:VcsAgentPool": return new VcsAgentPool(name, undefined, { urn }) + case "spacelift:index/version:Version": + return new Version(name, undefined, { urn }) case "spacelift:index/webhook:Webhook": return new Webhook(name, undefined, { urn }) case "spacelift:index/workerPool:WorkerPool": @@ -345,22 +494,34 @@ pulumi.runtime.registerResourceModule("spacelift", "index/awsIntegrationAttachme pulumi.runtime.registerResourceModule("spacelift", "index/awsRole", _module) pulumi.runtime.registerResourceModule("spacelift", "index/azureIntegration", _module) pulumi.runtime.registerResourceModule("spacelift", "index/azureIntegrationAttachment", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/blueprint", _module) pulumi.runtime.registerResourceModule("spacelift", "index/context", _module) pulumi.runtime.registerResourceModule("spacelift", "index/contextAttachment", _module) pulumi.runtime.registerResourceModule("spacelift", "index/driftDetection", _module) pulumi.runtime.registerResourceModule("spacelift", "index/environmentVariable", _module) pulumi.runtime.registerResourceModule("spacelift", "index/gcpServiceAccount", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/idpGroupMapping", _module) pulumi.runtime.registerResourceModule("spacelift", "index/module", _module) pulumi.runtime.registerResourceModule("spacelift", "index/mountedfile", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/namedWebhook", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/namedWebhookSecretHeader", _module) pulumi.runtime.registerResourceModule("spacelift", "index/policy", _module) pulumi.runtime.registerResourceModule("spacelift", "index/policyAttachment", _module) pulumi.runtime.registerResourceModule("spacelift", "index/run", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/scheduledDeleteTask", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/scheduledTask", _module) pulumi.runtime.registerResourceModule("spacelift", "index/space", _module) pulumi.runtime.registerResourceModule("spacelift", "index/stack", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/stackActivator", _module) pulumi.runtime.registerResourceModule("spacelift", "index/stackAwsRole", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/stackDependency", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/stackDependencyReference", _module) pulumi.runtime.registerResourceModule("spacelift", "index/stackDestructor", _module) pulumi.runtime.registerResourceModule("spacelift", "index/stackGcpServiceAccount", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/terraformProvider", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/user", _module) pulumi.runtime.registerResourceModule("spacelift", "index/vcsAgentPool", _module) +pulumi.runtime.registerResourceModule("spacelift", "index/version", _module) pulumi.runtime.registerResourceModule("spacelift", "index/webhook", _module) pulumi.runtime.registerResourceModule("spacelift", "index/workerPool", _module) pulumi.runtime.registerResourcePackage("spacelift", { diff --git a/sdk/nodejs/module.ts b/sdk/nodejs/module.ts index d521d5d..e96f9d6 100644 --- a/sdk/nodejs/module.ts +++ b/sdk/nodejs/module.ts @@ -11,7 +11,7 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * * // Explicit module name and provider: * const k8s_module = new spacelift.Module("k8s-module", { @@ -93,6 +93,10 @@ export class Module extends pulumi.CustomResource { * Free-form module description for users */ public readonly description!: pulumi.Output; + /** + * Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + */ + public readonly enableLocalPreview!: pulumi.Output; /** * GitHub Enterprise (self-hosted) VCS settings */ @@ -135,9 +139,13 @@ export class Module extends pulumi.CustomResource { */ public readonly terraformProvider!: pulumi.Output; /** - * ID of the worker pool to use + * ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. */ public readonly workerPoolId!: pulumi.Output; + /** + * Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + */ + public readonly workflowTool!: pulumi.Output; /** * Create a Module resource with the given unique name, arguments, and options. @@ -159,6 +167,7 @@ export class Module extends pulumi.CustomResource { resourceInputs["bitbucketDatacenter"] = state ? state.bitbucketDatacenter : undefined; resourceInputs["branch"] = state ? state.branch : undefined; resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["enableLocalPreview"] = state ? state.enableLocalPreview : undefined; resourceInputs["githubEnterprise"] = state ? state.githubEnterprise : undefined; resourceInputs["gitlab"] = state ? state.gitlab : undefined; resourceInputs["labels"] = state ? state.labels : undefined; @@ -170,6 +179,7 @@ export class Module extends pulumi.CustomResource { resourceInputs["spaceId"] = state ? state.spaceId : undefined; resourceInputs["terraformProvider"] = state ? state.terraformProvider : undefined; resourceInputs["workerPoolId"] = state ? state.workerPoolId : undefined; + resourceInputs["workflowTool"] = state ? state.workflowTool : undefined; } else { const args = argsOrState as ModuleArgs | undefined; if ((!args || args.branch === undefined) && !opts.urn) { @@ -184,6 +194,7 @@ export class Module extends pulumi.CustomResource { resourceInputs["bitbucketDatacenter"] = args ? args.bitbucketDatacenter : undefined; resourceInputs["branch"] = args ? args.branch : undefined; resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["enableLocalPreview"] = args ? args.enableLocalPreview : undefined; resourceInputs["githubEnterprise"] = args ? args.githubEnterprise : undefined; resourceInputs["gitlab"] = args ? args.gitlab : undefined; resourceInputs["labels"] = args ? args.labels : undefined; @@ -195,6 +206,7 @@ export class Module extends pulumi.CustomResource { resourceInputs["spaceId"] = args ? args.spaceId : undefined; resourceInputs["terraformProvider"] = args ? args.terraformProvider : undefined; resourceInputs["workerPoolId"] = args ? args.workerPoolId : undefined; + resourceInputs["workflowTool"] = args ? args.workflowTool : undefined; resourceInputs["awsAssumeRolePolicyStatement"] = undefined /*out*/; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); @@ -234,6 +246,10 @@ export interface ModuleState { * Free-form module description for users */ description?: pulumi.Input; + /** + * Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + */ + enableLocalPreview?: pulumi.Input; /** * GitHub Enterprise (self-hosted) VCS settings */ @@ -276,9 +292,13 @@ export interface ModuleState { */ terraformProvider?: pulumi.Input; /** - * ID of the worker pool to use + * ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. */ workerPoolId?: pulumi.Input; + /** + * Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + */ + workflowTool?: pulumi.Input; } /** @@ -309,6 +329,10 @@ export interface ModuleArgs { * Free-form module description for users */ description?: pulumi.Input; + /** + * Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + */ + enableLocalPreview?: pulumi.Input; /** * GitHub Enterprise (self-hosted) VCS settings */ @@ -351,7 +375,11 @@ export interface ModuleArgs { */ terraformProvider?: pulumi.Input; /** - * ID of the worker pool to use + * ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. */ workerPoolId?: pulumi.Input; + /** + * Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + */ + workflowTool?: pulumi.Input; } diff --git a/sdk/nodejs/mountedfile.ts b/sdk/nodejs/mountedfile.ts index abd5800..c39f5d9 100644 --- a/sdk/nodejs/mountedfile.ts +++ b/sdk/nodejs/mountedfile.ts @@ -133,7 +133,7 @@ export class Mountedfile extends pulumi.CustomResource { if ((!args || args.relativePath === undefined) && !opts.urn) { throw new Error("Missing required property 'relativePath'"); } - resourceInputs["content"] = args ? args.content : undefined; + resourceInputs["content"] = args?.content ? pulumi.secret(args.content) : undefined; resourceInputs["contextId"] = args ? args.contextId : undefined; resourceInputs["moduleId"] = args ? args.moduleId : undefined; resourceInputs["relativePath"] = args ? args.relativePath : undefined; @@ -142,6 +142,8 @@ export class Mountedfile extends pulumi.CustomResource { resourceInputs["checksum"] = undefined /*out*/; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["content"] }; + opts = pulumi.mergeOptions(opts, secretOpts); super(Mountedfile.__pulumiType, name, resourceInputs, opts); } } diff --git a/sdk/nodejs/namedWebhook.ts b/sdk/nodejs/namedWebhook.ts new file mode 100644 index 0000000..e233fce --- /dev/null +++ b/sdk/nodejs/namedWebhook.ts @@ -0,0 +1,165 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + */ +export class NamedWebhook extends pulumi.CustomResource { + /** + * Get an existing NamedWebhook resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: NamedWebhookState, opts?: pulumi.CustomResourceOptions): NamedWebhook { + return new NamedWebhook(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/namedWebhook:NamedWebhook'; + + /** + * Returns true if the given object is an instance of NamedWebhook. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is NamedWebhook { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === NamedWebhook.__pulumiType; + } + + /** + * enables or disables sending webhooks. + */ + public readonly enabled!: pulumi.Output; + /** + * endpoint to send the requests to + */ + public readonly endpoint!: pulumi.Output; + /** + * labels for the webhook to use when referring in policies or filtering them + */ + public readonly labels!: pulumi.Output; + /** + * the name for the webhook which will also be used to generate the id + */ + public readonly name!: pulumi.Output; + /** + * secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + */ + public readonly secret!: pulumi.Output; + /** + * ID of the space the webhook is in + */ + public readonly spaceId!: pulumi.Output; + + /** + * Create a NamedWebhook resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: NamedWebhookArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: NamedWebhookArgs | NamedWebhookState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as NamedWebhookState | undefined; + resourceInputs["enabled"] = state ? state.enabled : undefined; + resourceInputs["endpoint"] = state ? state.endpoint : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["secret"] = state ? state.secret : undefined; + resourceInputs["spaceId"] = state ? state.spaceId : undefined; + } else { + const args = argsOrState as NamedWebhookArgs | undefined; + if ((!args || args.enabled === undefined) && !opts.urn) { + throw new Error("Missing required property 'enabled'"); + } + if ((!args || args.endpoint === undefined) && !opts.urn) { + throw new Error("Missing required property 'endpoint'"); + } + if ((!args || args.spaceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'spaceId'"); + } + resourceInputs["enabled"] = args ? args.enabled : undefined; + resourceInputs["endpoint"] = args ? args.endpoint : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["secret"] = args?.secret ? pulumi.secret(args.secret) : undefined; + resourceInputs["spaceId"] = args ? args.spaceId : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["secret"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(NamedWebhook.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering NamedWebhook resources. + */ +export interface NamedWebhookState { + /** + * enables or disables sending webhooks. + */ + enabled?: pulumi.Input; + /** + * endpoint to send the requests to + */ + endpoint?: pulumi.Input; + /** + * labels for the webhook to use when referring in policies or filtering them + */ + labels?: pulumi.Input[]>; + /** + * the name for the webhook which will also be used to generate the id + */ + name?: pulumi.Input; + /** + * secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + */ + secret?: pulumi.Input; + /** + * ID of the space the webhook is in + */ + spaceId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a NamedWebhook resource. + */ +export interface NamedWebhookArgs { + /** + * enables or disables sending webhooks. + */ + enabled: pulumi.Input; + /** + * endpoint to send the requests to + */ + endpoint: pulumi.Input; + /** + * labels for the webhook to use when referring in policies or filtering them + */ + labels?: pulumi.Input[]>; + /** + * the name for the webhook which will also be used to generate the id + */ + name?: pulumi.Input; + /** + * secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + */ + secret?: pulumi.Input; + /** + * ID of the space the webhook is in + */ + spaceId: pulumi.Input; +} diff --git a/sdk/nodejs/namedWebhookSecretHeader.ts b/sdk/nodejs/namedWebhookSecretHeader.ts new file mode 100644 index 0000000..a74434c --- /dev/null +++ b/sdk/nodejs/namedWebhookSecretHeader.ts @@ -0,0 +1,123 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.NamedWebhookSecretHeader` represents secret key value combination used as a custom headerwhen delivering webhook requests. It depends on `spacelift.NamedWebhook` resource which should exist. + */ +export class NamedWebhookSecretHeader extends pulumi.CustomResource { + /** + * Get an existing NamedWebhookSecretHeader resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: NamedWebhookSecretHeaderState, opts?: pulumi.CustomResourceOptions): NamedWebhookSecretHeader { + return new NamedWebhookSecretHeader(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader'; + + /** + * Returns true if the given object is an instance of NamedWebhookSecretHeader. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is NamedWebhookSecretHeader { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === NamedWebhookSecretHeader.__pulumiType; + } + + /** + * key for the header + */ + public readonly key!: pulumi.Output; + /** + * value for the header + */ + public readonly value!: pulumi.Output; + /** + * ID of the stack on which the environment variable is defined + */ + public readonly webhookId!: pulumi.Output; + + /** + * Create a NamedWebhookSecretHeader resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: NamedWebhookSecretHeaderArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: NamedWebhookSecretHeaderArgs | NamedWebhookSecretHeaderState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as NamedWebhookSecretHeaderState | undefined; + resourceInputs["key"] = state ? state.key : undefined; + resourceInputs["value"] = state ? state.value : undefined; + resourceInputs["webhookId"] = state ? state.webhookId : undefined; + } else { + const args = argsOrState as NamedWebhookSecretHeaderArgs | undefined; + if ((!args || args.key === undefined) && !opts.urn) { + throw new Error("Missing required property 'key'"); + } + if ((!args || args.value === undefined) && !opts.urn) { + throw new Error("Missing required property 'value'"); + } + if ((!args || args.webhookId === undefined) && !opts.urn) { + throw new Error("Missing required property 'webhookId'"); + } + resourceInputs["key"] = args ? args.key : undefined; + resourceInputs["value"] = args?.value ? pulumi.secret(args.value) : undefined; + resourceInputs["webhookId"] = args ? args.webhookId : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["value"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(NamedWebhookSecretHeader.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering NamedWebhookSecretHeader resources. + */ +export interface NamedWebhookSecretHeaderState { + /** + * key for the header + */ + key?: pulumi.Input; + /** + * value for the header + */ + value?: pulumi.Input; + /** + * ID of the stack on which the environment variable is defined + */ + webhookId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a NamedWebhookSecretHeader resource. + */ +export interface NamedWebhookSecretHeaderArgs { + /** + * key for the header + */ + key: pulumi.Input; + /** + * value for the header + */ + value: pulumi.Input; + /** + * ID of the stack on which the environment variable is defined + */ + webhookId: pulumi.Input; +} diff --git a/sdk/nodejs/package.json b/sdk/nodejs/package.json index 5ef4256..ae9c35a 100644 --- a/sdk/nodejs/package.json +++ b/sdk/nodejs/package.json @@ -12,8 +12,7 @@ "repository": "git://github.com/spacelift-io/pulumi-spacelift.git", "license": "Apache-2.0", "scripts": { - "build": "tsc", - "install": "node scripts/install-pulumi-plugin.js resource spacelift ${VERSION}" + "build": "tsc" }, "dependencies": { "@pulumi/pulumi": "^3.0.0" diff --git a/sdk/nodejs/policy.ts b/sdk/nodejs/policy.ts index b4a615d..08854ee 100644 --- a/sdk/nodejs/policy.ts +++ b/sdk/nodejs/policy.ts @@ -76,7 +76,7 @@ export class Policy extends pulumi.CustomResource { */ public readonly spaceId!: pulumi.Output; /** - * Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + * Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). */ public readonly type!: pulumi.Output; @@ -135,7 +135,7 @@ export interface PolicyState { */ spaceId?: pulumi.Input; /** - * Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + * Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). */ type?: pulumi.Input; } @@ -158,7 +158,7 @@ export interface PolicyArgs { */ spaceId?: pulumi.Input; /** - * Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + * Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). */ type: pulumi.Input; } diff --git a/sdk/nodejs/provider.ts b/sdk/nodejs/provider.ts index 7dcb9a2..e221756 100644 --- a/sdk/nodejs/provider.ts +++ b/sdk/nodejs/provider.ts @@ -22,7 +22,7 @@ export class Provider extends pulumi.ProviderResource { if (obj === undefined || obj === null) { return false; } - return obj['__pulumiType'] === Provider.__pulumiType; + return obj['__pulumiType'] === "pulumi:providers:" + Provider.__pulumiType; } /** diff --git a/sdk/nodejs/scheduledDeleteTask.ts b/sdk/nodejs/scheduledDeleteTask.ts new file mode 100644 index 0000000..924480e --- /dev/null +++ b/sdk/nodejs/scheduledDeleteTask.ts @@ -0,0 +1,154 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const k8s_core = new spacelift.Stack("k8s-core", {}); + * // ... + * // at a given timestamp (unix) + * const k8s_core_delete = new spacelift.ScheduledDeleteTask("k8s-core-delete", { + * stackId: k8s_core.id, + * at: 1663336895, + * deleteResources: true, + * }); + * ``` + * + * ## Import + * + * ```sh + * $ pulumi import spacelift:index/scheduledDeleteTask:ScheduledDeleteTask ireland-kubeconfig $STACK_ID/$SCHEDULED_DELETE_STACK_ID + * ``` + */ +export class ScheduledDeleteTask extends pulumi.CustomResource { + /** + * Get an existing ScheduledDeleteTask resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: ScheduledDeleteTaskState, opts?: pulumi.CustomResourceOptions): ScheduledDeleteTask { + return new ScheduledDeleteTask(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/scheduledDeleteTask:ScheduledDeleteTask'; + + /** + * Returns true if the given object is an instance of ScheduledDeleteTask. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is ScheduledDeleteTask { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ScheduledDeleteTask.__pulumiType; + } + + /** + * Timestamp (unix timestamp) at which time the scheduling should happen. + */ + public readonly at!: pulumi.Output; + /** + * Indicates whether the resources of the stack should be deleted. + */ + public readonly deleteResources!: pulumi.Output; + /** + * ID of the schedule + */ + public readonly scheduleId!: pulumi.Output; + /** + * ID of the stack for which to set up scheduling + */ + public readonly stackId!: pulumi.Output; + + /** + * Create a ScheduledDeleteTask resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: ScheduledDeleteTaskArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ScheduledDeleteTaskArgs | ScheduledDeleteTaskState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ScheduledDeleteTaskState | undefined; + resourceInputs["at"] = state ? state.at : undefined; + resourceInputs["deleteResources"] = state ? state.deleteResources : undefined; + resourceInputs["scheduleId"] = state ? state.scheduleId : undefined; + resourceInputs["stackId"] = state ? state.stackId : undefined; + } else { + const args = argsOrState as ScheduledDeleteTaskArgs | undefined; + if ((!args || args.at === undefined) && !opts.urn) { + throw new Error("Missing required property 'at'"); + } + if ((!args || args.stackId === undefined) && !opts.urn) { + throw new Error("Missing required property 'stackId'"); + } + resourceInputs["at"] = args ? args.at : undefined; + resourceInputs["deleteResources"] = args ? args.deleteResources : undefined; + resourceInputs["scheduleId"] = args ? args.scheduleId : undefined; + resourceInputs["stackId"] = args ? args.stackId : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ScheduledDeleteTask.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ScheduledDeleteTask resources. + */ +export interface ScheduledDeleteTaskState { + /** + * Timestamp (unix timestamp) at which time the scheduling should happen. + */ + at?: pulumi.Input; + /** + * Indicates whether the resources of the stack should be deleted. + */ + deleteResources?: pulumi.Input; + /** + * ID of the schedule + */ + scheduleId?: pulumi.Input; + /** + * ID of the stack for which to set up scheduling + */ + stackId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ScheduledDeleteTask resource. + */ +export interface ScheduledDeleteTaskArgs { + /** + * Timestamp (unix timestamp) at which time the scheduling should happen. + */ + at: pulumi.Input; + /** + * Indicates whether the resources of the stack should be deleted. + */ + deleteResources?: pulumi.Input; + /** + * ID of the schedule + */ + scheduleId?: pulumi.Input; + /** + * ID of the stack for which to set up scheduling + */ + stackId: pulumi.Input; +} diff --git a/sdk/nodejs/scheduledTask.ts b/sdk/nodejs/scheduledTask.ts new file mode 100644 index 0000000..82d0b56 --- /dev/null +++ b/sdk/nodejs/scheduledTask.ts @@ -0,0 +1,196 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.ScheduledTask` represents a scheduling configuration for a Stack. It will trigger task on the given schedule or timestamp + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const k8s_core = new spacelift.Stack("k8s-core", {}); + * // ... + * // create the resources of a stack on a given schedule + * const k8s_core_create = new spacelift.ScheduledTask("k8s-core-create", { + * stackId: k8s_core.id, + * command: "pulumi up -auto-approve", + * everies: ["0 7 * * 1-5"], + * timezone: "CET", + * }); + * // destroy the resources of a stack on a given schedule + * const k8s_core_destroyScheduledTask = new spacelift.ScheduledTask("k8s-core-destroyScheduledTask", { + * stackId: k8s_core.id, + * command: "terraform destroy -auto-approve", + * everies: ["0 21 * * 1-5"], + * timezone: "CET", + * }); + * // at a given timestamp (unix) + * const k8s_core_destroyIndex_scheduledTaskScheduledTask = new spacelift.ScheduledTask("k8s-core-destroyIndex/scheduledTaskScheduledTask", { + * stackId: k8s_core.id, + * command: "terraform destroy -auto-approve", + * at: 1663336895, + * }); + * ``` + * + * ## Import + * + * ```sh + * $ pulumi import spacelift:index/scheduledTask:ScheduledTask ireland-kubeconfig $STACK_ID/$SCHEDULED_TASK_ID + * ``` + */ +export class ScheduledTask extends pulumi.CustomResource { + /** + * Get an existing ScheduledTask resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: ScheduledTaskState, opts?: pulumi.CustomResourceOptions): ScheduledTask { + return new ScheduledTask(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/scheduledTask:ScheduledTask'; + + /** + * Returns true if the given object is an instance of ScheduledTask. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is ScheduledTask { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ScheduledTask.__pulumiType; + } + + /** + * Timestamp (unix timestamp) at which time the scheduled task should happen. + */ + public readonly at!: pulumi.Output; + /** + * Command that will be run. + */ + public readonly command!: pulumi.Output; + /** + * List of cron schedule expressions based on which the scheduled task should be triggered. + */ + public readonly everies!: pulumi.Output; + /** + * ID of the schedule + */ + public readonly scheduleId!: pulumi.Output; + /** + * ID of the stack for which to set up the scheduled task + */ + public readonly stackId!: pulumi.Output; + /** + * Timezone in which the schedule is expressed. Defaults to `UTC`. + */ + public readonly timezone!: pulumi.Output; + + /** + * Create a ScheduledTask resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: ScheduledTaskArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ScheduledTaskArgs | ScheduledTaskState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ScheduledTaskState | undefined; + resourceInputs["at"] = state ? state.at : undefined; + resourceInputs["command"] = state ? state.command : undefined; + resourceInputs["everies"] = state ? state.everies : undefined; + resourceInputs["scheduleId"] = state ? state.scheduleId : undefined; + resourceInputs["stackId"] = state ? state.stackId : undefined; + resourceInputs["timezone"] = state ? state.timezone : undefined; + } else { + const args = argsOrState as ScheduledTaskArgs | undefined; + if ((!args || args.command === undefined) && !opts.urn) { + throw new Error("Missing required property 'command'"); + } + if ((!args || args.stackId === undefined) && !opts.urn) { + throw new Error("Missing required property 'stackId'"); + } + resourceInputs["at"] = args ? args.at : undefined; + resourceInputs["command"] = args ? args.command : undefined; + resourceInputs["everies"] = args ? args.everies : undefined; + resourceInputs["scheduleId"] = args ? args.scheduleId : undefined; + resourceInputs["stackId"] = args ? args.stackId : undefined; + resourceInputs["timezone"] = args ? args.timezone : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ScheduledTask.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ScheduledTask resources. + */ +export interface ScheduledTaskState { + /** + * Timestamp (unix timestamp) at which time the scheduled task should happen. + */ + at?: pulumi.Input; + /** + * Command that will be run. + */ + command?: pulumi.Input; + /** + * List of cron schedule expressions based on which the scheduled task should be triggered. + */ + everies?: pulumi.Input[]>; + /** + * ID of the schedule + */ + scheduleId?: pulumi.Input; + /** + * ID of the stack for which to set up the scheduled task + */ + stackId?: pulumi.Input; + /** + * Timezone in which the schedule is expressed. Defaults to `UTC`. + */ + timezone?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ScheduledTask resource. + */ +export interface ScheduledTaskArgs { + /** + * Timestamp (unix timestamp) at which time the scheduled task should happen. + */ + at?: pulumi.Input; + /** + * Command that will be run. + */ + command: pulumi.Input; + /** + * List of cron schedule expressions based on which the scheduled task should be triggered. + */ + everies?: pulumi.Input[]>; + /** + * ID of the schedule + */ + scheduleId?: pulumi.Input; + /** + * ID of the stack for which to set up the scheduled task + */ + stackId: pulumi.Input; + /** + * Timezone in which the schedule is expressed. Defaults to `UTC`. + */ + timezone?: pulumi.Input; +} diff --git a/sdk/nodejs/scripts/install-pulumi-plugin.js b/sdk/nodejs/scripts/install-pulumi-plugin.js deleted file mode 100644 index 4c8022f..0000000 --- a/sdk/nodejs/scripts/install-pulumi-plugin.js +++ /dev/null @@ -1,26 +0,0 @@ -"use strict"; -var childProcess = require("child_process"); - -var args = process.argv.slice(2); - -if (args.indexOf("${VERSION}") !== -1) { - process.exit(0); -} - -var res = childProcess.spawnSync("pulumi", ["plugin", "install", "--server", "https://downloads.spacelift.io/pulumi-plugins"].concat(args), { - stdio: ["ignore", "inherit", "inherit"] -}); - -if (res.error && res.error.code === "ENOENT") { - console.error("\nThere was an error installing the resource provider plugin. " + - "It looks like `pulumi` is not installed on your system. " + - "Please visit https://pulumi.com/ to install the Pulumi CLI.\n" + - "You may try manually installing the plugin by running " + - "`pulumi plugin install " + args.join(" ") + "`"); -} else if (res.error || res.status !== 0) { - console.error("\nThere was an error installing the resource provider plugin. " + - "You may try to manually installing the plugin by running " + - "`pulumi plugin install " + args.join(" ") + "`"); -} - -process.exit(0); diff --git a/sdk/nodejs/space.ts b/sdk/nodejs/space.ts index 1babcf5..35007ee 100644 --- a/sdk/nodejs/space.ts +++ b/sdk/nodejs/space.ts @@ -65,6 +65,10 @@ export class Space extends pulumi.CustomResource { * indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. */ public readonly inheritEntities!: pulumi.Output; + /** + * list of labels describing a space + */ + public readonly labels!: pulumi.Output; /** * name of the space */ @@ -89,12 +93,14 @@ export class Space extends pulumi.CustomResource { const state = argsOrState as SpaceState | undefined; resourceInputs["description"] = state ? state.description : undefined; resourceInputs["inheritEntities"] = state ? state.inheritEntities : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; resourceInputs["name"] = state ? state.name : undefined; resourceInputs["parentSpaceId"] = state ? state.parentSpaceId : undefined; } else { const args = argsOrState as SpaceArgs | undefined; resourceInputs["description"] = args ? args.description : undefined; resourceInputs["inheritEntities"] = args ? args.inheritEntities : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; resourceInputs["name"] = args ? args.name : undefined; resourceInputs["parentSpaceId"] = args ? args.parentSpaceId : undefined; } @@ -115,6 +121,10 @@ export interface SpaceState { * indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. */ inheritEntities?: pulumi.Input; + /** + * list of labels describing a space + */ + labels?: pulumi.Input[]>; /** * name of the space */ @@ -137,6 +147,10 @@ export interface SpaceArgs { * indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. */ inheritEntities?: pulumi.Input; + /** + * list of labels describing a space + */ + labels?: pulumi.Input[]>; /** * name of the space */ diff --git a/sdk/nodejs/stack.ts b/sdk/nodejs/stack.ts index 5b78501..b4b1dc9 100644 --- a/sdk/nodejs/stack.ts +++ b/sdk/nodejs/stack.ts @@ -13,46 +13,46 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * * // Terraform stack using Bitbucket Cloud as VCS * const k8s_cluster_bitbucket_cloud = new spacelift.Stack("k8s-cluster-bitbucket-cloud", { * administrative: true, * autodeploy: true, * bitbucketCloud: { - * namespace: "SPACELIFT", // The Bitbucket project containing the repository + * namespace: "SPACELIFT", * }, * branch: "master", * description: "Provisions a Kubernetes cluster", * projectRoot: "cluster", * repository: "core-infra", - * terraformVersion: "0.12.6", + * terraformVersion: "1.3.0", * }); * // Terraform stack using Bitbucket Data Center as VCS * const k8s_cluster_bitbucket_datacenter = new spacelift.Stack("k8s-cluster-bitbucket-datacenter", { * administrative: true, * autodeploy: true, * bitbucketDatacenter: { - * namespace: "SPACELIFT", // The Bitbucket project containing the repository + * namespace: "SPACELIFT", * }, * branch: "master", * description: "Provisions a Kubernetes cluster", * projectRoot: "cluster", * repository: "core-infra", - * terraformVersion: "0.12.6", + * terraformVersion: "1.3.0", * }); - * // Terraform stack using GitHub Enterprise as VCS + * // Terraform stack using a GitHub Custom Application. See the following page for more info: https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application * const k8s_cluster_github_enterprise = new spacelift.Stack("k8s-cluster-github-enterprise", { * administrative: true, * autodeploy: true, * branch: "master", * description: "Provisions a Kubernetes cluster", * githubEnterprise: { - * namespace: "spacelift", // The GitHub organization / user the repository belongs to + * namespace: "spacelift", * }, * projectRoot: "cluster", * repository: "core-infra", - * terraformVersion: "0.12.6", + * terraformVersion: "1.3.0", * }); * // Terraform stack using GitLab as VCS * const k8s_cluster_gitlab = new spacelift.Stack("k8s-cluster-gitlab", { @@ -61,13 +61,13 @@ import * as utilities from "./utilities"; * branch: "master", * description: "Provisions a Kubernetes cluster", * gitlab: { - * namespace: "spacelift", // The GitLab namespace containing the repository + * namespace: "spacelift", * }, * projectRoot: "cluster", * repository: "core-infra", - * terraformVersion: "0.12.6", + * terraformVersion: "1.3.0", * }); - * // Terraform stack using github.com as VCS and enabling smart sanitization + * // Terraform stack using github.com as VCS and enabling external state access * const k8s_cluster = new spacelift.Stack("k8s-cluster", { * administrative: true, * autodeploy: true, @@ -75,8 +75,8 @@ import * as utilities from "./utilities"; * description: "Provisions a Kubernetes cluster", * projectRoot: "cluster", * repository: "core-infra", - * terraformSmartSanitization: true, - * terraformVersion: "1.2.6", + * terraformExternalStateAccess: true, + * terraformVersion: "1.3.0", * }); * // CloudFormation stack using github.com as VCS * const k8s_cluster_cloudformation = new spacelift.Stack("k8s-cluster-cloudformation", { @@ -108,11 +108,11 @@ import * as utilities from "./utilities"; * // Kubernetes stack using github.com as VCS * const k8s_core_kubernetes = new spacelift.Stack("k8s-core-kubernetes", { * autodeploy: true, - * // You can use hooks to authenticate with your cluster * beforeInits: ["aws eks update-kubeconfig --region us-east-2 --name k8s-cluster"], * branch: "master", * description: "Shared cluster services (Datadog, Istio etc.)", * kubernetes: { + * kubectlVersion: "1.26.1", * namespace: "core", * }, * projectRoot: "core-services", @@ -189,6 +189,10 @@ export class Stack extends pulumi.CustomResource { * List of after-plan scripts */ public readonly afterPlans!: pulumi.Output; + /** + * List of after-run scripts + */ + public readonly afterRuns!: pulumi.Output; /** * Ansible-specific configuration. Presence means this Stack is an Ansible Stack. */ @@ -254,11 +258,11 @@ export class Stack extends pulumi.CustomResource { */ public readonly enableLocalPreview!: pulumi.Output; /** - * Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + * Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. */ public readonly githubActionDeploy!: pulumi.Output; /** - * GitHub Enterprise (self-hosted) VCS settings + * VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) */ public readonly githubEnterprise!: pulumi.Output; /** @@ -298,6 +302,10 @@ export class Stack extends pulumi.CustomResource { * Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. */ public readonly pulumi!: pulumi.Output; + /** + * One-way VCS integration using a raw Git repository link + */ + public readonly rawGit!: pulumi.Output; /** * Name of the repository, without the owner part */ @@ -312,9 +320,13 @@ export class Stack extends pulumi.CustomResource { */ public readonly slug!: pulumi.Output; /** - * ID (slug) of the space the stack is in + * ID (slug) of the space the stack is in. Defaults to `legacy`. */ public readonly spaceId!: pulumi.Output; + /** + * Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + */ + public readonly terraformExternalStateAccess!: pulumi.Output; /** * Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state * and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. @@ -325,12 +337,20 @@ export class Stack extends pulumi.CustomResource { * Terraform version to use */ public readonly terraformVersion!: pulumi.Output; + /** + * Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + */ + public readonly terraformWorkflowTool!: pulumi.Output; /** * Terraform workspace to select */ public readonly terraformWorkspace!: pulumi.Output; /** - * ID of the worker pool to use + * Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + */ + public readonly terragrunt!: pulumi.Output; + /** + * ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. */ public readonly workerPoolId!: pulumi.Output; @@ -353,6 +373,7 @@ export class Stack extends pulumi.CustomResource { resourceInputs["afterInits"] = state ? state.afterInits : undefined; resourceInputs["afterPerforms"] = state ? state.afterPerforms : undefined; resourceInputs["afterPlans"] = state ? state.afterPlans : undefined; + resourceInputs["afterRuns"] = state ? state.afterRuns : undefined; resourceInputs["ansible"] = state ? state.ansible : undefined; resourceInputs["autodeploy"] = state ? state.autodeploy : undefined; resourceInputs["autoretry"] = state ? state.autoretry : undefined; @@ -381,14 +402,18 @@ export class Stack extends pulumi.CustomResource { resourceInputs["projectRoot"] = state ? state.projectRoot : undefined; resourceInputs["protectFromDeletion"] = state ? state.protectFromDeletion : undefined; resourceInputs["pulumi"] = state ? state.pulumi : undefined; + resourceInputs["rawGit"] = state ? state.rawGit : undefined; resourceInputs["repository"] = state ? state.repository : undefined; resourceInputs["runnerImage"] = state ? state.runnerImage : undefined; resourceInputs["showcase"] = state ? state.showcase : undefined; resourceInputs["slug"] = state ? state.slug : undefined; resourceInputs["spaceId"] = state ? state.spaceId : undefined; + resourceInputs["terraformExternalStateAccess"] = state ? state.terraformExternalStateAccess : undefined; resourceInputs["terraformSmartSanitization"] = state ? state.terraformSmartSanitization : undefined; resourceInputs["terraformVersion"] = state ? state.terraformVersion : undefined; + resourceInputs["terraformWorkflowTool"] = state ? state.terraformWorkflowTool : undefined; resourceInputs["terraformWorkspace"] = state ? state.terraformWorkspace : undefined; + resourceInputs["terragrunt"] = state ? state.terragrunt : undefined; resourceInputs["workerPoolId"] = state ? state.workerPoolId : undefined; } else { const args = argsOrState as StackArgs | undefined; @@ -404,6 +429,7 @@ export class Stack extends pulumi.CustomResource { resourceInputs["afterInits"] = args ? args.afterInits : undefined; resourceInputs["afterPerforms"] = args ? args.afterPerforms : undefined; resourceInputs["afterPlans"] = args ? args.afterPlans : undefined; + resourceInputs["afterRuns"] = args ? args.afterRuns : undefined; resourceInputs["ansible"] = args ? args.ansible : undefined; resourceInputs["autodeploy"] = args ? args.autodeploy : undefined; resourceInputs["autoretry"] = args ? args.autoretry : undefined; @@ -422,7 +448,7 @@ export class Stack extends pulumi.CustomResource { resourceInputs["githubActionDeploy"] = args ? args.githubActionDeploy : undefined; resourceInputs["githubEnterprise"] = args ? args.githubEnterprise : undefined; resourceInputs["gitlab"] = args ? args.gitlab : undefined; - resourceInputs["importState"] = args ? args.importState : undefined; + resourceInputs["importState"] = args?.importState ? pulumi.secret(args.importState) : undefined; resourceInputs["importStateFile"] = args ? args.importStateFile : undefined; resourceInputs["kubernetes"] = args ? args.kubernetes : undefined; resourceInputs["labels"] = args ? args.labels : undefined; @@ -431,18 +457,24 @@ export class Stack extends pulumi.CustomResource { resourceInputs["projectRoot"] = args ? args.projectRoot : undefined; resourceInputs["protectFromDeletion"] = args ? args.protectFromDeletion : undefined; resourceInputs["pulumi"] = args ? args.pulumi : undefined; + resourceInputs["rawGit"] = args ? args.rawGit : undefined; resourceInputs["repository"] = args ? args.repository : undefined; resourceInputs["runnerImage"] = args ? args.runnerImage : undefined; resourceInputs["showcase"] = args ? args.showcase : undefined; resourceInputs["slug"] = args ? args.slug : undefined; resourceInputs["spaceId"] = args ? args.spaceId : undefined; + resourceInputs["terraformExternalStateAccess"] = args ? args.terraformExternalStateAccess : undefined; resourceInputs["terraformSmartSanitization"] = args ? args.terraformSmartSanitization : undefined; resourceInputs["terraformVersion"] = args ? args.terraformVersion : undefined; + resourceInputs["terraformWorkflowTool"] = args ? args.terraformWorkflowTool : undefined; resourceInputs["terraformWorkspace"] = args ? args.terraformWorkspace : undefined; + resourceInputs["terragrunt"] = args ? args.terragrunt : undefined; resourceInputs["workerPoolId"] = args ? args.workerPoolId : undefined; resourceInputs["awsAssumeRolePolicyStatement"] = undefined /*out*/; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["importState"] }; + opts = pulumi.mergeOptions(opts, secretOpts); super(Stack.__pulumiType, name, resourceInputs, opts); } } @@ -475,6 +507,10 @@ export interface StackState { * List of after-plan scripts */ afterPlans?: pulumi.Input[]>; + /** + * List of after-run scripts + */ + afterRuns?: pulumi.Input[]>; /** * Ansible-specific configuration. Presence means this Stack is an Ansible Stack. */ @@ -540,11 +576,11 @@ export interface StackState { */ enableLocalPreview?: pulumi.Input; /** - * Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + * Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. */ githubActionDeploy?: pulumi.Input; /** - * GitHub Enterprise (self-hosted) VCS settings + * VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) */ githubEnterprise?: pulumi.Input; /** @@ -584,6 +620,10 @@ export interface StackState { * Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. */ pulumi?: pulumi.Input; + /** + * One-way VCS integration using a raw Git repository link + */ + rawGit?: pulumi.Input; /** * Name of the repository, without the owner part */ @@ -598,9 +638,13 @@ export interface StackState { */ slug?: pulumi.Input; /** - * ID (slug) of the space the stack is in + * ID (slug) of the space the stack is in. Defaults to `legacy`. */ spaceId?: pulumi.Input; + /** + * Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + */ + terraformExternalStateAccess?: pulumi.Input; /** * Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state * and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. @@ -611,12 +655,20 @@ export interface StackState { * Terraform version to use */ terraformVersion?: pulumi.Input; + /** + * Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + */ + terraformWorkflowTool?: pulumi.Input; /** * Terraform workspace to select */ terraformWorkspace?: pulumi.Input; /** - * ID of the worker pool to use + * Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + */ + terragrunt?: pulumi.Input; + /** + * ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. */ workerPoolId?: pulumi.Input; } @@ -649,6 +701,10 @@ export interface StackArgs { * List of after-plan scripts */ afterPlans?: pulumi.Input[]>; + /** + * List of after-run scripts + */ + afterRuns?: pulumi.Input[]>; /** * Ansible-specific configuration. Presence means this Stack is an Ansible Stack. */ @@ -710,11 +766,11 @@ export interface StackArgs { */ enableLocalPreview?: pulumi.Input; /** - * Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + * Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. */ githubActionDeploy?: pulumi.Input; /** - * GitHub Enterprise (self-hosted) VCS settings + * VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) */ githubEnterprise?: pulumi.Input; /** @@ -754,6 +810,10 @@ export interface StackArgs { * Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. */ pulumi?: pulumi.Input; + /** + * One-way VCS integration using a raw Git repository link + */ + rawGit?: pulumi.Input; /** * Name of the repository, without the owner part */ @@ -768,9 +828,13 @@ export interface StackArgs { */ slug?: pulumi.Input; /** - * ID (slug) of the space the stack is in + * ID (slug) of the space the stack is in. Defaults to `legacy`. */ spaceId?: pulumi.Input; + /** + * Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + */ + terraformExternalStateAccess?: pulumi.Input; /** * Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state * and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. @@ -781,12 +845,20 @@ export interface StackArgs { * Terraform version to use */ terraformVersion?: pulumi.Input; + /** + * Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + */ + terraformWorkflowTool?: pulumi.Input; /** * Terraform workspace to select */ terraformWorkspace?: pulumi.Input; /** - * ID of the worker pool to use + * Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + */ + terragrunt?: pulumi.Input; + /** + * ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. */ workerPoolId?: pulumi.Input; } diff --git a/sdk/nodejs/stackActivator.ts b/sdk/nodejs/stackActivator.ts new file mode 100644 index 0000000..b1cfd41 --- /dev/null +++ b/sdk/nodejs/stackActivator.ts @@ -0,0 +1,120 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.StackActivator` is used to to enable/disable Spacelift Stack. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const app = new spacelift.Stack("app", { + * branch: "master", + * repository: "app", + * }); + * const test = new spacelift.StackActivator("test", { + * enabled: true, + * stackId: app.id, + * }); + * ``` + */ +export class StackActivator extends pulumi.CustomResource { + /** + * Get an existing StackActivator resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: StackActivatorState, opts?: pulumi.CustomResourceOptions): StackActivator { + return new StackActivator(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/stackActivator:StackActivator'; + + /** + * Returns true if the given object is an instance of StackActivator. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is StackActivator { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === StackActivator.__pulumiType; + } + + /** + * Enable/disable stack + */ + public readonly enabled!: pulumi.Output; + /** + * ID of the stack to enable/disable + */ + public readonly stackId!: pulumi.Output; + + /** + * Create a StackActivator resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: StackActivatorArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: StackActivatorArgs | StackActivatorState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as StackActivatorState | undefined; + resourceInputs["enabled"] = state ? state.enabled : undefined; + resourceInputs["stackId"] = state ? state.stackId : undefined; + } else { + const args = argsOrState as StackActivatorArgs | undefined; + if ((!args || args.enabled === undefined) && !opts.urn) { + throw new Error("Missing required property 'enabled'"); + } + if ((!args || args.stackId === undefined) && !opts.urn) { + throw new Error("Missing required property 'stackId'"); + } + resourceInputs["enabled"] = args ? args.enabled : undefined; + resourceInputs["stackId"] = args ? args.stackId : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(StackActivator.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering StackActivator resources. + */ +export interface StackActivatorState { + /** + * Enable/disable stack + */ + enabled?: pulumi.Input; + /** + * ID of the stack to enable/disable + */ + stackId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a StackActivator resource. + */ +export interface StackActivatorArgs { + /** + * Enable/disable stack + */ + enabled: pulumi.Input; + /** + * ID of the stack to enable/disable + */ + stackId: pulumi.Input; +} diff --git a/sdk/nodejs/stackDependency.ts b/sdk/nodejs/stackDependency.ts new file mode 100644 index 0000000..a1164e1 --- /dev/null +++ b/sdk/nodejs/stackDependency.ts @@ -0,0 +1,124 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.StackDependency` represents a Spacelift **stack dependency** - a dependency between two stacks. When one stack depends on another, the tracked runs of the stack will not start until the dependent stack is successfully finished. Additionally, changes to the dependency will trigger the dependent. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const infra = new spacelift.Stack("infra", { + * branch: "master", + * repository: "core-infra", + * }); + * const app = new spacelift.Stack("app", { + * branch: "master", + * repository: "app", + * }); + * const test = new spacelift.StackDependency("test", { + * stackId: app.id, + * dependsOnStackId: infra.id, + * }); + * ``` + */ +export class StackDependency extends pulumi.CustomResource { + /** + * Get an existing StackDependency resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: StackDependencyState, opts?: pulumi.CustomResourceOptions): StackDependency { + return new StackDependency(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/stackDependency:StackDependency'; + + /** + * Returns true if the given object is an instance of StackDependency. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is StackDependency { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === StackDependency.__pulumiType; + } + + /** + * immutable ID (slug) of stack to depend on. + */ + public readonly dependsOnStackId!: pulumi.Output; + /** + * immutable ID (slug) of stack which has a dependency. + */ + public readonly stackId!: pulumi.Output; + + /** + * Create a StackDependency resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: StackDependencyArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: StackDependencyArgs | StackDependencyState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as StackDependencyState | undefined; + resourceInputs["dependsOnStackId"] = state ? state.dependsOnStackId : undefined; + resourceInputs["stackId"] = state ? state.stackId : undefined; + } else { + const args = argsOrState as StackDependencyArgs | undefined; + if ((!args || args.dependsOnStackId === undefined) && !opts.urn) { + throw new Error("Missing required property 'dependsOnStackId'"); + } + if ((!args || args.stackId === undefined) && !opts.urn) { + throw new Error("Missing required property 'stackId'"); + } + resourceInputs["dependsOnStackId"] = args ? args.dependsOnStackId : undefined; + resourceInputs["stackId"] = args ? args.stackId : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(StackDependency.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering StackDependency resources. + */ +export interface StackDependencyState { + /** + * immutable ID (slug) of stack to depend on. + */ + dependsOnStackId?: pulumi.Input; + /** + * immutable ID (slug) of stack which has a dependency. + */ + stackId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a StackDependency resource. + */ +export interface StackDependencyArgs { + /** + * immutable ID (slug) of stack to depend on. + */ + dependsOnStackId: pulumi.Input; + /** + * immutable ID (slug) of stack which has a dependency. + */ + stackId: pulumi.Input; +} diff --git a/sdk/nodejs/stackDependencyReference.ts b/sdk/nodejs/stackDependencyReference.ts new file mode 100644 index 0000000..9729c1d --- /dev/null +++ b/sdk/nodejs/stackDependencyReference.ts @@ -0,0 +1,146 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.StackDependencyReference` represents a Spacelift **stack dependency reference** - a reference matches a stack's output to another stack's input. It is similar to an environment variable (`spacelift.EnvironmentVariable`), except that value is provided by another stack's output. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const infra = new spacelift.Stack("infra", { + * branch: "master", + * repository: "core-infra", + * }); + * const app = new spacelift.Stack("app", { + * branch: "master", + * repository: "app", + * }); + * const testStackDependency = new spacelift.StackDependency("testStackDependency", { + * stackId: app.id, + * dependsOnStackId: infra.id, + * }); + * const testStackDependencyReference = new spacelift.StackDependencyReference("testStackDependencyReference", { + * stackDependencyId: testStackDependency.id, + * outputName: "DB_CONNECTION_STRING", + * inputName: "APP_DB_URL", + * }); + * ``` + */ +export class StackDependencyReference extends pulumi.CustomResource { + /** + * Get an existing StackDependencyReference resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: StackDependencyReferenceState, opts?: pulumi.CustomResourceOptions): StackDependencyReference { + return new StackDependencyReference(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/stackDependencyReference:StackDependencyReference'; + + /** + * Returns true if the given object is an instance of StackDependencyReference. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is StackDependencyReference { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === StackDependencyReference.__pulumiType; + } + + /** + * Name of the input of the stack dependency reference + */ + public readonly inputName!: pulumi.Output; + /** + * Name of the output of stack to depend on + */ + public readonly outputName!: pulumi.Output; + /** + * Immutable ID of stack dependency + */ + public readonly stackDependencyId!: pulumi.Output; + + /** + * Create a StackDependencyReference resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: StackDependencyReferenceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: StackDependencyReferenceArgs | StackDependencyReferenceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as StackDependencyReferenceState | undefined; + resourceInputs["inputName"] = state ? state.inputName : undefined; + resourceInputs["outputName"] = state ? state.outputName : undefined; + resourceInputs["stackDependencyId"] = state ? state.stackDependencyId : undefined; + } else { + const args = argsOrState as StackDependencyReferenceArgs | undefined; + if ((!args || args.inputName === undefined) && !opts.urn) { + throw new Error("Missing required property 'inputName'"); + } + if ((!args || args.outputName === undefined) && !opts.urn) { + throw new Error("Missing required property 'outputName'"); + } + if ((!args || args.stackDependencyId === undefined) && !opts.urn) { + throw new Error("Missing required property 'stackDependencyId'"); + } + resourceInputs["inputName"] = args ? args.inputName : undefined; + resourceInputs["outputName"] = args ? args.outputName : undefined; + resourceInputs["stackDependencyId"] = args ? args.stackDependencyId : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(StackDependencyReference.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering StackDependencyReference resources. + */ +export interface StackDependencyReferenceState { + /** + * Name of the input of the stack dependency reference + */ + inputName?: pulumi.Input; + /** + * Name of the output of stack to depend on + */ + outputName?: pulumi.Input; + /** + * Immutable ID of stack dependency + */ + stackDependencyId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a StackDependencyReference resource. + */ +export interface StackDependencyReferenceArgs { + /** + * Name of the input of the stack dependency reference + */ + inputName: pulumi.Input; + /** + * Name of the output of stack to depend on + */ + outputName: pulumi.Input; + /** + * Immutable ID of stack dependency + */ + stackDependencyId: pulumi.Input; +} diff --git a/sdk/nodejs/stackGcpServiceAccount.ts b/sdk/nodejs/stackGcpServiceAccount.ts index d6940a3..382823c 100644 --- a/sdk/nodejs/stackGcpServiceAccount.ts +++ b/sdk/nodejs/stackGcpServiceAccount.ts @@ -9,7 +9,7 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as gcp from "@pulumi/gcp"; + * import * as google from "@pulumi/google"; * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * * const k8s_coreStack = new spacelift.Stack("k8s-coreStack", { @@ -24,14 +24,15 @@ import * as utilities from "./utilities"; * "https://www.googleapis.com/auth/devstorage.full_control", * ], * }); - * const k8s_coreProject = new gcp.organizations.Project("k8s-coreProject", { + * const k8s_coregoogle_project = new google.index.Google_project("k8s-coregoogle_project", { + * name: "Kubernetes code", * projectId: "unicorn-k8s-core", * orgId: _var.gcp_organization_id, * }); - * const k8s_coreIAMMember = new gcp.projects.IAMMember("k8s-coreIAMMember", { - * project: k8s_coreProject.id, + * const k8s_coregoogle_project_iam_member = new google.index.Google_project_iam_member("k8s-coregoogle_project_iam_member", { + * project: k8s_coregoogle_project.id, * role: "roles/owner", - * member: pulumi.interpolate`serviceAccount:${k8s_coreStackGcpServiceAccount.serviceAccountEmail}`, + * member: `serviceAccount:${k8s_coreStackGcpServiceAccount.serviceAccountEmail}`, * }); * ``` */ diff --git a/sdk/nodejs/terraformProvider.ts b/sdk/nodejs/terraformProvider.ts new file mode 100644 index 0000000..5406dff --- /dev/null +++ b/sdk/nodejs/terraformProvider.ts @@ -0,0 +1,150 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; + * + * const datadog = new spacelift.TerraformProvider("datadog", { + * description: "Our fork of the Datadog provider", + * labels: ["fork"], + * "public": false, + * spaceId: "root", + * type: "datadog", + * }); + * ``` + */ +export class TerraformProvider extends pulumi.CustomResource { + /** + * Get an existing TerraformProvider resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: TerraformProviderState, opts?: pulumi.CustomResourceOptions): TerraformProvider { + return new TerraformProvider(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/terraformProvider:TerraformProvider'; + + /** + * Returns true if the given object is an instance of TerraformProvider. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is TerraformProvider { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === TerraformProvider.__pulumiType; + } + + /** + * Free-form description for human users, supports Markdown + */ + public readonly description!: pulumi.Output; + public readonly labels!: pulumi.Output; + /** + * Whether the provider is public or not, defaults to false (private) + */ + public readonly public!: pulumi.Output; + /** + * ID (slug) of the space the provider is in + */ + public readonly spaceId!: pulumi.Output; + /** + * Type of the provider - should be unique in one account + */ + public readonly type!: pulumi.Output; + + /** + * Create a TerraformProvider resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: TerraformProviderArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: TerraformProviderArgs | TerraformProviderState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as TerraformProviderState | undefined; + resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["public"] = state ? state.public : undefined; + resourceInputs["spaceId"] = state ? state.spaceId : undefined; + resourceInputs["type"] = state ? state.type : undefined; + } else { + const args = argsOrState as TerraformProviderArgs | undefined; + if ((!args || args.spaceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'spaceId'"); + } + if ((!args || args.type === undefined) && !opts.urn) { + throw new Error("Missing required property 'type'"); + } + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["public"] = args ? args.public : undefined; + resourceInputs["spaceId"] = args ? args.spaceId : undefined; + resourceInputs["type"] = args ? args.type : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(TerraformProvider.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering TerraformProvider resources. + */ +export interface TerraformProviderState { + /** + * Free-form description for human users, supports Markdown + */ + description?: pulumi.Input; + labels?: pulumi.Input[]>; + /** + * Whether the provider is public or not, defaults to false (private) + */ + public?: pulumi.Input; + /** + * ID (slug) of the space the provider is in + */ + spaceId?: pulumi.Input; + /** + * Type of the provider - should be unique in one account + */ + type?: pulumi.Input; +} + +/** + * The set of arguments for constructing a TerraformProvider resource. + */ +export interface TerraformProviderArgs { + /** + * Free-form description for human users, supports Markdown + */ + description?: pulumi.Input; + labels?: pulumi.Input[]>; + /** + * Whether the provider is public or not, defaults to false (private) + */ + public?: pulumi.Input; + /** + * ID (slug) of the space the provider is in + */ + spaceId: pulumi.Input; + /** + * Type of the provider - should be unique in one account + */ + type: pulumi.Input; +} diff --git a/sdk/nodejs/tsconfig.json b/sdk/nodejs/tsconfig.json index 2ce68ec..9f13306 100644 --- a/sdk/nodejs/tsconfig.json +++ b/sdk/nodejs/tsconfig.json @@ -18,6 +18,7 @@ "awsRole.ts", "azureIntegration.ts", "azureIntegrationAttachment.ts", + "blueprint.ts", "config/index.ts", "config/vars.ts", "context.ts", @@ -29,51 +30,73 @@ "getAwsIntegration.ts", "getAwsIntegrationAttachment.ts", "getAwsIntegrationAttachmentExternalId.ts", + "getAwsIntegrations.ts", "getAwsRole.ts", "getAzureDevopsIntegration.ts", "getAzureIntegration.ts", "getAzureIntegrationAttachment.ts", + "getAzureIntegrations.ts", "getBitbucketCloudIntegration.ts", "getBitbucketDatacenterIntegration.ts", "getContext.ts", "getContextAttachment.ts", + "getContexts.ts", + "getCurrentSpace.ts", "getCurrentStack.ts", "getDriftDetection.ts", "getEnvironmentVariable.ts", "getGcpServiceAccount.ts", "getGithubEnterpriseIntegration.ts", "getGitlabIntegration.ts", + "getGitlabWebhookEndpoint.ts", "getIPs.ts", "getModule.ts", "getMountedfile.ts", + "getNamedWebhook.ts", "getPolicies.ts", "getPolicy.ts", + "getScheduledDeleteStack.ts", + "getScheduledTask.ts", "getSpace.ts", + "getSpaceByPath.ts", + "getSpaces.ts", "getStack.ts", "getStackAwsRole.ts", "getStackGcpServiceAccount.ts", + "getStacks.ts", "getVcsAgentPool.ts", "getVcsAgentPools.ts", "getWebhook.ts", "getWorkerPool.ts", "getWorkerPools.ts", + "idpGroupMapping.ts", "index.ts", "module.ts", "mountedfile.ts", + "namedWebhook.ts", + "namedWebhookSecretHeader.ts", "policy.ts", "policyAttachment.ts", "provider.ts", "run.ts", + "scheduledDeleteTask.ts", + "scheduledTask.ts", "space.ts", "stack.ts", + "stackActivator.ts", "stackAwsRole.ts", + "stackDependency.ts", + "stackDependencyReference.ts", "stackDestructor.ts", "stackGcpServiceAccount.ts", + "terraformProvider.ts", "types/index.ts", "types/input.ts", "types/output.ts", + "user.ts", "utilities.ts", "vcsAgentPool.ts", + "version.ts", "webhook.ts", "workerPool.ts" ] diff --git a/sdk/nodejs/types/input.ts b/sdk/nodejs/types/input.ts index 03e53da..843c607 100644 --- a/sdk/nodejs/types/input.ts +++ b/sdk/nodejs/types/input.ts @@ -5,6 +5,113 @@ import * as pulumi from "@pulumi/pulumi"; import * as inputs from "../types/input"; import * as outputs from "../types/output"; +export interface GetContextsLabel { + anyOfs: string[]; +} + +export interface GetContextsLabelArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksAdministrative { + equals?: boolean; +} + +export interface GetStacksAdministrativeArgs { + equals?: pulumi.Input; +} + +export interface GetStacksBranch { + anyOfs: string[]; +} + +export interface GetStacksBranchArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksCommit { + anyOfs: string[]; +} + +export interface GetStacksCommitArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksLabel { + anyOfs: string[]; +} + +export interface GetStacksLabelArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksLocked { + equals?: boolean; +} + +export interface GetStacksLockedArgs { + equals?: pulumi.Input; +} + +export interface GetStacksName { + anyOfs: string[]; +} + +export interface GetStacksNameArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksProjectRoot { + anyOfs: string[]; +} + +export interface GetStacksProjectRootArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksRepository { + anyOfs: string[]; +} + +export interface GetStacksRepositoryArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksState { + anyOfs: string[]; +} + +export interface GetStacksStateArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksVendor { + anyOfs: string[]; +} + +export interface GetStacksVendorArgs { + anyOfs: pulumi.Input[]>; +} + +export interface GetStacksWorkerPool { + anyOfs: string[]; +} + +export interface GetStacksWorkerPoolArgs { + anyOfs: pulumi.Input[]>; +} + +export interface IdpGroupMappingPolicy { + /** + * Type of access to the space. Possible values are: READ, WRITE, ADMIN + */ + role: pulumi.Input; + /** + * ID (slug) of the space the user group has access to + */ + spaceId: pulumi.Input; +} + export interface ModuleAzureDevops { /** * The name of the Azure DevOps project @@ -102,6 +209,10 @@ export interface StackGitlab { } export interface StackKubernetes { + /** + * Kubectl version. + */ + kubectlVersion?: pulumi.Input; /** * Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. */ @@ -119,6 +230,41 @@ export interface StackPulumi { stackName: pulumi.Input; } +export interface StackRawGit { + /** + * User-friendly namespace for the repository, this is for cosmetic purposes only + */ + namespace: pulumi.Input; + /** + * HTTPS URL of the Git repository + */ + url: pulumi.Input; +} + export interface StackShowcase { namespace: pulumi.Input; } + +export interface StackTerragrunt { + terraformVersion?: pulumi.Input; + /** + * Terragrunt version. + */ + terragruntVersion?: pulumi.Input; + /** + * Whether to use `terragrunt run-all` instead of `terragrunt`. + */ + useRunAll?: pulumi.Input; + useSmartSanitization?: pulumi.Input; +} + +export interface UserPolicy { + /** + * Type of access to the space. Possible values are: READ, WRITE, ADMIN + */ + role: pulumi.Input; + /** + * ID (slug) of the space the user has access to + */ + spaceId: pulumi.Input; +} diff --git a/sdk/nodejs/types/output.ts b/sdk/nodejs/types/output.ts index e75a66d..d37d375 100644 --- a/sdk/nodejs/types/output.ts +++ b/sdk/nodejs/types/output.ts @@ -5,6 +5,42 @@ import * as pulumi from "@pulumi/pulumi"; import * as inputs from "../types/input"; import * as outputs from "../types/output"; +export interface GetAwsIntegrationsIntegration { + durationSeconds: number; + externalId: string; + generateCredentialsInWorker: boolean; + integrationId: string; + labels: string[]; + name: string; + roleArn: string; + spaceId: string; +} + +export interface GetAzureIntegrationsIntegration { + adminConsentProvided: boolean; + adminConsentUrl: string; + applicationId: string; + defaultSubscriptionId: string; + displayName: string; + integrationId: string; + labels: string[]; + name: string; + spaceId: string; + tenantId: string; +} + +export interface GetContextsContext { + contextId: string; + description: string; + labels: string[]; + name: string; + spaceId: string; +} + +export interface GetContextsLabel { + anyOfs: string[]; +} + export interface GetModuleAzureDevop { project: string; } @@ -26,22 +62,22 @@ export interface GetModuleGitlab { } export interface GetPoliciesPolicy { - /** - * The ID of this resource. - */ id: string; - /** - * required labels to match - */ labels: string[]; name: string; spaceId: string; - /** - * required policy type - */ type: string; } +export interface GetSpacesSpace { + description: string; + inheritEntities: boolean; + labels: string[]; + name: string; + parentSpaceId: string; + spaceId: string; +} + export interface GetStackAnsible { playbook: string; } @@ -74,6 +110,7 @@ export interface GetStackGitlab { } export interface GetStackKubernete { + kubectlVersion: string; namespace: string; } @@ -82,10 +119,156 @@ export interface GetStackPulumi { stackName: string; } +export interface GetStackRawGit { + namespace: string; + url: string; +} + export interface GetStackShowcase { namespace: string; } +export interface GetStacksAdministrative { + equals?: boolean; +} + +export interface GetStacksBranch { + anyOfs: string[]; +} + +export interface GetStacksCommit { + anyOfs: string[]; +} + +export interface GetStacksLabel { + anyOfs: string[]; +} + +export interface GetStacksLocked { + equals?: boolean; +} + +export interface GetStacksName { + anyOfs: string[]; +} + +export interface GetStacksProjectRoot { + anyOfs: string[]; +} + +export interface GetStacksRepository { + anyOfs: string[]; +} + +export interface GetStacksStack { + administrative: boolean; + afterApplies: string[]; + afterDestroys: string[]; + afterInits: string[]; + afterPerforms: string[]; + afterPlans: string[]; + afterRuns?: string[]; + ansibles: outputs.GetStacksStackAnsible[]; + autodeploy: boolean; + autoretry: boolean; + awsAssumeRolePolicyStatement: string; + azureDevops: outputs.GetStacksStackAzureDevop[]; + beforeApplies: string[]; + beforeDestroys: string[]; + beforeInits: string[]; + beforePerforms: string[]; + beforePlans: string[]; + bitbucketClouds: outputs.GetStacksStackBitbucketCloud[]; + bitbucketDatacenters: outputs.GetStacksStackBitbucketDatacenter[]; + branch: string; + cloudformations: outputs.GetStacksStackCloudformation[]; + description: string; + enableLocalPreview: boolean; + githubEnterprises: outputs.GetStacksStackGithubEnterprise[]; + gitlabs: outputs.GetStacksStackGitlab[]; + kubernetes: outputs.GetStacksStackKubernete[]; + labels: string[]; + manageState: boolean; + name: string; + projectRoot: string; + protectFromDeletion: boolean; + pulumis: outputs.GetStacksStackPulumi[]; + rawGits: outputs.GetStacksStackRawGit[]; + repository: string; + runnerImage: string; + showcases: outputs.GetStacksStackShowcase[]; + spaceId: string; + stackId: string; + terraformExternalStateAccess: boolean; + terraformSmartSanitization: boolean; + terraformVersion: string; + terraformWorkflowTool: string; + terraformWorkspace: string; + workerPoolId: string; +} + +export interface GetStacksStackAnsible { + playbook: string; +} + +export interface GetStacksStackAzureDevop { + project: string; +} + +export interface GetStacksStackBitbucketCloud { + namespace: string; +} + +export interface GetStacksStackBitbucketDatacenter { + namespace: string; +} + +export interface GetStacksStackCloudformation { + entryTemplateFile: string; + region: string; + stackName: string; + templateBucket: string; +} + +export interface GetStacksStackGithubEnterprise { + namespace: string; +} + +export interface GetStacksStackGitlab { + namespace: string; +} + +export interface GetStacksStackKubernete { + kubectlVersion: string; + namespace: string; +} + +export interface GetStacksStackPulumi { + loginUrl: string; + stackName: string; +} + +export interface GetStacksStackRawGit { + namespace: string; + url: string; +} + +export interface GetStacksStackShowcase { + namespace: string; +} + +export interface GetStacksState { + anyOfs: string[]; +} + +export interface GetStacksVendor { + anyOfs: string[]; +} + +export interface GetStacksWorkerPool { + anyOfs: string[]; +} + export interface GetVcsAgentPoolsVcsAgentPool { description: string; name: string; @@ -100,6 +283,17 @@ export interface GetWorkerPoolsWorkerPool { workerPoolId: string; } +export interface IdpGroupMappingPolicy { + /** + * Type of access to the space. Possible values are: READ, WRITE, ADMIN + */ + role: string; + /** + * ID (slug) of the space the user group has access to + */ + spaceId: string; +} + export interface ModuleAzureDevops { /** * The name of the Azure DevOps project @@ -197,6 +391,10 @@ export interface StackGitlab { } export interface StackKubernetes { + /** + * Kubectl version. + */ + kubectlVersion: string; /** * Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. */ @@ -214,7 +412,42 @@ export interface StackPulumi { stackName: string; } +export interface StackRawGit { + /** + * User-friendly namespace for the repository, this is for cosmetic purposes only + */ + namespace: string; + /** + * HTTPS URL of the Git repository + */ + url: string; +} + export interface StackShowcase { namespace: string; } +export interface StackTerragrunt { + terraformVersion: string; + /** + * Terragrunt version. + */ + terragruntVersion: string; + /** + * Whether to use `terragrunt run-all` instead of `terragrunt`. + */ + useRunAll?: boolean; + useSmartSanitization?: boolean; +} + +export interface UserPolicy { + /** + * Type of access to the space. Possible values are: READ, WRITE, ADMIN + */ + role: string; + /** + * ID (slug) of the space the user has access to + */ + spaceId: string; +} + diff --git a/sdk/nodejs/user.ts b/sdk/nodejs/user.ts new file mode 100644 index 0000000..48f69a4 --- /dev/null +++ b/sdk/nodejs/user.ts @@ -0,0 +1,114 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * `spacelift.User` represents a mapping between a Spacelift user (managed using an Identity Provider) and a Policy. A Policy defines what access rights the user has to a given Space. + */ +export class User extends pulumi.CustomResource { + /** + * Get an existing User resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: UserState, opts?: pulumi.CustomResourceOptions): User { + return new User(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/user:User'; + + /** + * Returns true if the given object is an instance of User. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is User { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === User.__pulumiType; + } + + /** + * Email of the user. Used for sending an invitation. + */ + public readonly invitationEmail!: pulumi.Output; + public readonly policies!: pulumi.Output; + /** + * Username of the user + */ + public readonly username!: pulumi.Output; + + /** + * Create a User resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: UserArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: UserArgs | UserState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as UserState | undefined; + resourceInputs["invitationEmail"] = state ? state.invitationEmail : undefined; + resourceInputs["policies"] = state ? state.policies : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as UserArgs | undefined; + if ((!args || args.invitationEmail === undefined) && !opts.urn) { + throw new Error("Missing required property 'invitationEmail'"); + } + if ((!args || args.policies === undefined) && !opts.urn) { + throw new Error("Missing required property 'policies'"); + } + if ((!args || args.username === undefined) && !opts.urn) { + throw new Error("Missing required property 'username'"); + } + resourceInputs["invitationEmail"] = args ? args.invitationEmail : undefined; + resourceInputs["policies"] = args ? args.policies : undefined; + resourceInputs["username"] = args ? args.username : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(User.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering User resources. + */ +export interface UserState { + /** + * Email of the user. Used for sending an invitation. + */ + invitationEmail?: pulumi.Input; + policies?: pulumi.Input[]>; + /** + * Username of the user + */ + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a User resource. + */ +export interface UserArgs { + /** + * Email of the user. Used for sending an invitation. + */ + invitationEmail: pulumi.Input; + policies: pulumi.Input[]>; + /** + * Username of the user + */ + username: pulumi.Input; +} diff --git a/sdk/nodejs/vcsAgentPool.ts b/sdk/nodejs/vcsAgentPool.ts index 5fcf09c..0be49a3 100644 --- a/sdk/nodejs/vcsAgentPool.ts +++ b/sdk/nodejs/vcsAgentPool.ts @@ -11,11 +11,9 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * - * const ghe = new spacelift.VcsAgentPool("ghe", { - * description: "VCS agent pool for our internal GitHub Enterprise", - * }); + * const ghe = new spacelift.VcsAgentPool("ghe", {description: "VCS agent pool for our internal GitHub Enterprise"}); * ``` * * ## Import @@ -88,6 +86,8 @@ export class VcsAgentPool extends pulumi.CustomResource { resourceInputs["config"] = undefined /*out*/; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["config"] }; + opts = pulumi.mergeOptions(opts, secretOpts); super(VcsAgentPool.__pulumiType, name, resourceInputs, opts); } } diff --git a/sdk/nodejs/version.ts b/sdk/nodejs/version.ts new file mode 100644 index 0000000..50c7c89 --- /dev/null +++ b/sdk/nodejs/version.ts @@ -0,0 +1,129 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as utilities from "./utilities"; + +/** + * `spacelift.Version` allows to programmatically trigger a version creation in response to arbitrary changes in the keepers section. + */ +export class Version extends pulumi.CustomResource { + /** + * Get an existing Version resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: VersionState, opts?: pulumi.CustomResourceOptions): Version { + return new Version(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'spacelift:index/version:Version'; + + /** + * Returns true if the given object is an instance of Version. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is Version { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === Version.__pulumiType; + } + + /** + * The commit SHA for which to trigger a version. + */ + public readonly commitSha!: pulumi.Output; + /** + * Arbitrary map of values that, when changed, will trigger recreation of the resource. + */ + public readonly keepers!: pulumi.Output<{[key: string]: any} | undefined>; + /** + * ID of the module on which the version creation is to be triggered. + */ + public readonly moduleId!: pulumi.Output; + /** + * A semantic version number to set for the triggered version, example: 0.11.2 + */ + public readonly versionNumber!: pulumi.Output; + + /** + * Create a Version resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: VersionArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: VersionArgs | VersionState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as VersionState | undefined; + resourceInputs["commitSha"] = state ? state.commitSha : undefined; + resourceInputs["keepers"] = state ? state.keepers : undefined; + resourceInputs["moduleId"] = state ? state.moduleId : undefined; + resourceInputs["versionNumber"] = state ? state.versionNumber : undefined; + } else { + const args = argsOrState as VersionArgs | undefined; + if ((!args || args.moduleId === undefined) && !opts.urn) { + throw new Error("Missing required property 'moduleId'"); + } + resourceInputs["commitSha"] = args ? args.commitSha : undefined; + resourceInputs["keepers"] = args ? args.keepers : undefined; + resourceInputs["moduleId"] = args ? args.moduleId : undefined; + resourceInputs["versionNumber"] = args ? args.versionNumber : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Version.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering Version resources. + */ +export interface VersionState { + /** + * The commit SHA for which to trigger a version. + */ + commitSha?: pulumi.Input; + /** + * Arbitrary map of values that, when changed, will trigger recreation of the resource. + */ + keepers?: pulumi.Input<{[key: string]: any}>; + /** + * ID of the module on which the version creation is to be triggered. + */ + moduleId?: pulumi.Input; + /** + * A semantic version number to set for the triggered version, example: 0.11.2 + */ + versionNumber?: pulumi.Input; +} + +/** + * The set of arguments for constructing a Version resource. + */ +export interface VersionArgs { + /** + * The commit SHA for which to trigger a version. + */ + commitSha?: pulumi.Input; + /** + * Arbitrary map of values that, when changed, will trigger recreation of the resource. + */ + keepers?: pulumi.Input<{[key: string]: any}>; + /** + * ID of the module on which the version creation is to be triggered. + */ + moduleId: pulumi.Input; + /** + * A semantic version number to set for the triggered version, example: 0.11.2 + */ + versionNumber?: pulumi.Input; +} diff --git a/sdk/nodejs/webhook.ts b/sdk/nodejs/webhook.ts index 4fa607a..553d341 100644 --- a/sdk/nodejs/webhook.ts +++ b/sdk/nodejs/webhook.ts @@ -11,7 +11,7 @@ import * as utilities from "./utilities"; * * ```typescript * import * as pulumi from "@pulumi/pulumi"; - * import * as spacelift from "@pulumi/spacelift"; + * import * as spacelift from "@spacelift-io/pulumi-spacelift"; * * const webhook = new spacelift.Webhook("webhook", { * endpoint: "https://example.com/webhooks", @@ -100,10 +100,12 @@ export class Webhook extends pulumi.CustomResource { resourceInputs["enabled"] = args ? args.enabled : undefined; resourceInputs["endpoint"] = args ? args.endpoint : undefined; resourceInputs["moduleId"] = args ? args.moduleId : undefined; - resourceInputs["secret"] = args ? args.secret : undefined; + resourceInputs["secret"] = args?.secret ? pulumi.secret(args.secret) : undefined; resourceInputs["stackId"] = args ? args.stackId : undefined; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["secret"] }; + opts = pulumi.mergeOptions(opts, secretOpts); super(Webhook.__pulumiType, name, resourceInputs, opts); } } diff --git a/sdk/nodejs/workerPool.ts b/sdk/nodejs/workerPool.ts index f7223b2..6cbfa56 100644 --- a/sdk/nodejs/workerPool.ts +++ b/sdk/nodejs/workerPool.ts @@ -102,7 +102,7 @@ export class WorkerPool extends pulumi.CustomResource { resourceInputs["spaceId"] = state ? state.spaceId : undefined; } else { const args = argsOrState as WorkerPoolArgs | undefined; - resourceInputs["csr"] = args ? args.csr : undefined; + resourceInputs["csr"] = args?.csr ? pulumi.secret(args.csr) : undefined; resourceInputs["description"] = args ? args.description : undefined; resourceInputs["labels"] = args ? args.labels : undefined; resourceInputs["name"] = args ? args.name : undefined; @@ -111,6 +111,8 @@ export class WorkerPool extends pulumi.CustomResource { resourceInputs["privateKey"] = undefined /*out*/; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["config", "csr", "privateKey"] }; + opts = pulumi.mergeOptions(opts, secretOpts); super(WorkerPool.__pulumiType, name, resourceInputs, opts); } } diff --git a/sdk/python/pulumi_spacelift/__init__.py b/sdk/python/pulumi_spacelift/__init__.py index e044485..ae3fc6f 100644 --- a/sdk/python/pulumi_spacelift/__init__.py +++ b/sdk/python/pulumi_spacelift/__init__.py @@ -10,6 +10,7 @@ from .aws_role import * from .azure_integration import * from .azure_integration_attachment import * +from .blueprint import * from .context import * from .context_attachment import * from .drift_detection import * @@ -19,46 +20,68 @@ from .get_aws_integration import * from .get_aws_integration_attachment import * from .get_aws_integration_attachment_external_id import * +from .get_aws_integrations import * from .get_aws_role import * from .get_azure_devops_integration import * from .get_azure_integration import * from .get_azure_integration_attachment import * +from .get_azure_integrations import * from .get_bitbucket_cloud_integration import * from .get_bitbucket_datacenter_integration import * from .get_context import * from .get_context_attachment import * +from .get_contexts import * +from .get_current_space import * from .get_current_stack import * from .get_drift_detection import * from .get_environment_variable import * from .get_gcp_service_account import * from .get_github_enterprise_integration import * from .get_gitlab_integration import * +from .get_gitlab_webhook_endpoint import * from .get_ips import * from .get_module import * from .get_mountedfile import * +from .get_named_webhook import * from .get_policies import * from .get_policy import * +from .get_scheduled_delete_stack import * +from .get_scheduled_task import * from .get_space import * +from .get_space_by_path import * +from .get_spaces import * from .get_stack import * from .get_stack_aws_role import * from .get_stack_gcp_service_account import * +from .get_stacks import * from .get_vcs_agent_pool import * from .get_vcs_agent_pools import * from .get_webhook import * from .get_worker_pool import * from .get_worker_pools import * +from .idp_group_mapping import * from .module import * from .mountedfile import * +from .named_webhook import * +from .named_webhook_secret_header import * from .policy import * from .policy_attachment import * from .provider import * from .run import * +from .scheduled_delete_task import * +from .scheduled_task import * from .space import * from .stack import * +from .stack_activator import * from .stack_aws_role import * +from .stack_dependency import * +from .stack_dependency_reference import * from .stack_destructor import * from .stack_gcp_service_account import * +from .terraform_provider import * +from .user import * from .vcs_agent_pool import * +from .version import * from .webhook import * from .worker_pool import * from ._inputs import * @@ -114,6 +137,14 @@ "spacelift:index/azureIntegrationAttachment:AzureIntegrationAttachment": "AzureIntegrationAttachment" } }, + { + "pkg": "spacelift", + "mod": "index/blueprint", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/blueprint:Blueprint": "Blueprint" + } + }, { "pkg": "spacelift", "mod": "index/context", @@ -154,6 +185,14 @@ "spacelift:index/gcpServiceAccount:GcpServiceAccount": "GcpServiceAccount" } }, + { + "pkg": "spacelift", + "mod": "index/idpGroupMapping", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/idpGroupMapping:IdpGroupMapping": "IdpGroupMapping" + } + }, { "pkg": "spacelift", "mod": "index/module", @@ -170,6 +209,22 @@ "spacelift:index/mountedfile:Mountedfile": "Mountedfile" } }, + { + "pkg": "spacelift", + "mod": "index/namedWebhook", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/namedWebhook:NamedWebhook": "NamedWebhook" + } + }, + { + "pkg": "spacelift", + "mod": "index/namedWebhookSecretHeader", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader": "NamedWebhookSecretHeader" + } + }, { "pkg": "spacelift", "mod": "index/policy", @@ -194,6 +249,22 @@ "spacelift:index/run:Run": "Run" } }, + { + "pkg": "spacelift", + "mod": "index/scheduledDeleteTask", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/scheduledDeleteTask:ScheduledDeleteTask": "ScheduledDeleteTask" + } + }, + { + "pkg": "spacelift", + "mod": "index/scheduledTask", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/scheduledTask:ScheduledTask": "ScheduledTask" + } + }, { "pkg": "spacelift", "mod": "index/space", @@ -210,6 +281,14 @@ "spacelift:index/stack:Stack": "Stack" } }, + { + "pkg": "spacelift", + "mod": "index/stackActivator", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/stackActivator:StackActivator": "StackActivator" + } + }, { "pkg": "spacelift", "mod": "index/stackAwsRole", @@ -218,6 +297,22 @@ "spacelift:index/stackAwsRole:StackAwsRole": "StackAwsRole" } }, + { + "pkg": "spacelift", + "mod": "index/stackDependency", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/stackDependency:StackDependency": "StackDependency" + } + }, + { + "pkg": "spacelift", + "mod": "index/stackDependencyReference", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/stackDependencyReference:StackDependencyReference": "StackDependencyReference" + } + }, { "pkg": "spacelift", "mod": "index/stackDestructor", @@ -234,6 +329,22 @@ "spacelift:index/stackGcpServiceAccount:StackGcpServiceAccount": "StackGcpServiceAccount" } }, + { + "pkg": "spacelift", + "mod": "index/terraformProvider", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/terraformProvider:TerraformProvider": "TerraformProvider" + } + }, + { + "pkg": "spacelift", + "mod": "index/user", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/user:User": "User" + } + }, { "pkg": "spacelift", "mod": "index/vcsAgentPool", @@ -242,6 +353,14 @@ "spacelift:index/vcsAgentPool:VcsAgentPool": "VcsAgentPool" } }, + { + "pkg": "spacelift", + "mod": "index/version", + "fqn": "pulumi_spacelift", + "classes": { + "spacelift:index/version:Version": "Version" + } + }, { "pkg": "spacelift", "mod": "index/webhook", diff --git a/sdk/python/pulumi_spacelift/_inputs.py b/sdk/python/pulumi_spacelift/_inputs.py index fb1e9e8..afd7aba 100644 --- a/sdk/python/pulumi_spacelift/_inputs.py +++ b/sdk/python/pulumi_spacelift/_inputs.py @@ -6,10 +6,11 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ + 'IdpGroupMappingPolicyArgs', 'ModuleAzureDevopsArgs', 'ModuleBitbucketCloudArgs', 'ModuleBitbucketDatacenterArgs', @@ -24,9 +25,80 @@ 'StackGitlabArgs', 'StackKubernetesArgs', 'StackPulumiArgs', + 'StackRawGitArgs', 'StackShowcaseArgs', + 'StackTerragruntArgs', + 'UserPolicyArgs', + 'GetContextsLabelArgs', + 'GetStacksAdministrativeArgs', + 'GetStacksBranchArgs', + 'GetStacksCommitArgs', + 'GetStacksLabelArgs', + 'GetStacksLockedArgs', + 'GetStacksNameArgs', + 'GetStacksProjectRootArgs', + 'GetStacksRepositoryArgs', + 'GetStacksStateArgs', + 'GetStacksVendorArgs', + 'GetStacksWorkerPoolArgs', ] +@pulumi.input_type +class IdpGroupMappingPolicyArgs: + def __init__(__self__, *, + role: pulumi.Input[str], + space_id: pulumi.Input[str]): + """ + :param pulumi.Input[str] role: Type of access to the space. Possible values are: READ, WRITE, ADMIN + :param pulumi.Input[str] space_id: ID (slug) of the space the user group has access to + """ + IdpGroupMappingPolicyArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + role=role, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + role: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if role is None: + raise TypeError("Missing 'role' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + + _setter("role", role) + _setter("space_id", space_id) + + @property + @pulumi.getter + def role(self) -> pulumi.Input[str]: + """ + Type of access to the space. Possible values are: READ, WRITE, ADMIN + """ + return pulumi.get(self, "role") + + @role.setter + def role(self, value: pulumi.Input[str]): + pulumi.set(self, "role", value) + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> pulumi.Input[str]: + """ + ID (slug) of the space the user group has access to + """ + return pulumi.get(self, "space_id") + + @space_id.setter + def space_id(self, value: pulumi.Input[str]): + pulumi.set(self, "space_id", value) + + @pulumi.input_type class ModuleAzureDevopsArgs: def __init__(__self__, *, @@ -34,7 +106,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] project: The name of the Azure DevOps project """ - pulumi.set(__self__, "project", project) + ModuleAzureDevopsArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + project=project, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + project: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if project is None: + raise TypeError("Missing 'project' argument") + + _setter("project", project) @property @pulumi.getter @@ -56,7 +141,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] namespace: The Bitbucket project containing the repository """ - pulumi.set(__self__, "namespace", namespace) + ModuleBitbucketCloudArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -78,7 +176,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] namespace: The Bitbucket project containing the repository """ - pulumi.set(__self__, "namespace", namespace) + ModuleBitbucketDatacenterArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -100,7 +211,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] namespace: The GitHub organization / user the repository belongs to """ - pulumi.set(__self__, "namespace", namespace) + ModuleGithubEnterpriseArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -122,7 +246,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] namespace: The GitLab namespace containing the repository """ - pulumi.set(__self__, "namespace", namespace) + ModuleGitlabArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -144,7 +281,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] playbook: The playbook Ansible should run. """ - pulumi.set(__self__, "playbook", playbook) + StackAnsibleArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + playbook=playbook, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + playbook: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if playbook is None: + raise TypeError("Missing 'playbook' argument") + + _setter("playbook", playbook) @property @pulumi.getter @@ -166,7 +316,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] project: The name of the Azure DevOps project """ - pulumi.set(__self__, "project", project) + StackAzureDevopsArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + project=project, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + project: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if project is None: + raise TypeError("Missing 'project' argument") + + _setter("project", project) @property @pulumi.getter @@ -188,7 +351,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] namespace: The Bitbucket project containing the repository """ - pulumi.set(__self__, "namespace", namespace) + StackBitbucketCloudArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -210,7 +386,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] namespace: The Bitbucket project containing the repository """ - pulumi.set(__self__, "namespace", namespace) + StackBitbucketDatacenterArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -238,10 +427,41 @@ def __init__(__self__, *, :param pulumi.Input[str] stack_name: CloudFormation stack name :param pulumi.Input[str] template_bucket: S3 bucket to save CloudFormation templates to """ - pulumi.set(__self__, "entry_template_file", entry_template_file) - pulumi.set(__self__, "region", region) - pulumi.set(__self__, "stack_name", stack_name) - pulumi.set(__self__, "template_bucket", template_bucket) + StackCloudformationArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + entry_template_file=entry_template_file, + region=region, + stack_name=stack_name, + template_bucket=template_bucket, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + entry_template_file: Optional[pulumi.Input[str]] = None, + region: Optional[pulumi.Input[str]] = None, + stack_name: Optional[pulumi.Input[str]] = None, + template_bucket: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if entry_template_file is None and 'entryTemplateFile' in kwargs: + entry_template_file = kwargs['entryTemplateFile'] + if entry_template_file is None: + raise TypeError("Missing 'entry_template_file' argument") + if region is None: + raise TypeError("Missing 'region' argument") + if stack_name is None and 'stackName' in kwargs: + stack_name = kwargs['stackName'] + if stack_name is None: + raise TypeError("Missing 'stack_name' argument") + if template_bucket is None and 'templateBucket' in kwargs: + template_bucket = kwargs['templateBucket'] + if template_bucket is None: + raise TypeError("Missing 'template_bucket' argument") + + _setter("entry_template_file", entry_template_file) + _setter("region", region) + _setter("stack_name", stack_name) + _setter("template_bucket", template_bucket) @property @pulumi.getter(name="entryTemplateFile") @@ -299,7 +519,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] namespace: The GitHub organization / user the repository belongs to """ - pulumi.set(__self__, "namespace", namespace) + StackGithubEnterpriseArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -321,7 +554,20 @@ def __init__(__self__, *, """ :param pulumi.Input[str] namespace: The GitLab namespace containing the repository """ - pulumi.set(__self__, "namespace", namespace) + StackGitlabArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -339,12 +585,43 @@ def namespace(self, value: pulumi.Input[str]): @pulumi.input_type class StackKubernetesArgs: def __init__(__self__, *, + kubectl_version: Optional[pulumi.Input[str]] = None, namespace: Optional[pulumi.Input[str]] = None): """ + :param pulumi.Input[str] kubectl_version: Kubectl version. :param pulumi.Input[str] namespace: Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. """ + StackKubernetesArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + kubectl_version=kubectl_version, + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + kubectl_version: Optional[pulumi.Input[str]] = None, + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if kubectl_version is None and 'kubectlVersion' in kwargs: + kubectl_version = kwargs['kubectlVersion'] + + if kubectl_version is not None: + _setter("kubectl_version", kubectl_version) if namespace is not None: - pulumi.set(__self__, "namespace", namespace) + _setter("namespace", namespace) + + @property + @pulumi.getter(name="kubectlVersion") + def kubectl_version(self) -> Optional[pulumi.Input[str]]: + """ + Kubectl version. + """ + return pulumi.get(self, "kubectl_version") + + @kubectl_version.setter + def kubectl_version(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "kubectl_version", value) @property @pulumi.getter @@ -368,8 +645,29 @@ def __init__(__self__, *, :param pulumi.Input[str] login_url: State backend to log into on Run initialize. :param pulumi.Input[str] stack_name: Pulumi stack name to use with the state backend. """ - pulumi.set(__self__, "login_url", login_url) - pulumi.set(__self__, "stack_name", stack_name) + StackPulumiArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + login_url=login_url, + stack_name=stack_name, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + login_url: Optional[pulumi.Input[str]] = None, + stack_name: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if login_url is None and 'loginUrl' in kwargs: + login_url = kwargs['loginUrl'] + if login_url is None: + raise TypeError("Missing 'login_url' argument") + if stack_name is None and 'stackName' in kwargs: + stack_name = kwargs['stackName'] + if stack_name is None: + raise TypeError("Missing 'stack_name' argument") + + _setter("login_url", login_url) + _setter("stack_name", stack_name) @property @pulumi.getter(name="loginUrl") @@ -396,11 +694,78 @@ def stack_name(self, value: pulumi.Input[str]): pulumi.set(self, "stack_name", value) +@pulumi.input_type +class StackRawGitArgs: + def __init__(__self__, *, + namespace: pulumi.Input[str], + url: pulumi.Input[str]): + """ + :param pulumi.Input[str] namespace: User-friendly namespace for the repository, this is for cosmetic purposes only + :param pulumi.Input[str] url: HTTPS URL of the Git repository + """ + StackRawGitArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + url=url, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + url: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + if url is None: + raise TypeError("Missing 'url' argument") + + _setter("namespace", namespace) + _setter("url", url) + + @property + @pulumi.getter + def namespace(self) -> pulumi.Input[str]: + """ + User-friendly namespace for the repository, this is for cosmetic purposes only + """ + return pulumi.get(self, "namespace") + + @namespace.setter + def namespace(self, value: pulumi.Input[str]): + pulumi.set(self, "namespace", value) + + @property + @pulumi.getter + def url(self) -> pulumi.Input[str]: + """ + HTTPS URL of the Git repository + """ + return pulumi.get(self, "url") + + @url.setter + def url(self, value: pulumi.Input[str]): + pulumi.set(self, "url", value) + + @pulumi.input_type class StackShowcaseArgs: def __init__(__self__, *, namespace: pulumi.Input[str]): - pulumi.set(__self__, "namespace", namespace) + StackShowcaseArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -412,3 +777,513 @@ def namespace(self, value: pulumi.Input[str]): pulumi.set(self, "namespace", value) +@pulumi.input_type +class StackTerragruntArgs: + def __init__(__self__, *, + terraform_version: Optional[pulumi.Input[str]] = None, + terragrunt_version: Optional[pulumi.Input[str]] = None, + use_run_all: Optional[pulumi.Input[bool]] = None, + use_smart_sanitization: Optional[pulumi.Input[bool]] = None): + """ + :param pulumi.Input[str] terragrunt_version: Terragrunt version. + :param pulumi.Input[bool] use_run_all: Whether to use `terragrunt run-all` instead of `terragrunt`. + """ + StackTerragruntArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + terraform_version=terraform_version, + terragrunt_version=terragrunt_version, + use_run_all=use_run_all, + use_smart_sanitization=use_smart_sanitization, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + terraform_version: Optional[pulumi.Input[str]] = None, + terragrunt_version: Optional[pulumi.Input[str]] = None, + use_run_all: Optional[pulumi.Input[bool]] = None, + use_smart_sanitization: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if terraform_version is None and 'terraformVersion' in kwargs: + terraform_version = kwargs['terraformVersion'] + if terragrunt_version is None and 'terragruntVersion' in kwargs: + terragrunt_version = kwargs['terragruntVersion'] + if use_run_all is None and 'useRunAll' in kwargs: + use_run_all = kwargs['useRunAll'] + if use_smart_sanitization is None and 'useSmartSanitization' in kwargs: + use_smart_sanitization = kwargs['useSmartSanitization'] + + if terraform_version is not None: + _setter("terraform_version", terraform_version) + if terragrunt_version is not None: + _setter("terragrunt_version", terragrunt_version) + if use_run_all is not None: + _setter("use_run_all", use_run_all) + if use_smart_sanitization is not None: + _setter("use_smart_sanitization", use_smart_sanitization) + + @property + @pulumi.getter(name="terraformVersion") + def terraform_version(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "terraform_version") + + @terraform_version.setter + def terraform_version(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "terraform_version", value) + + @property + @pulumi.getter(name="terragruntVersion") + def terragrunt_version(self) -> Optional[pulumi.Input[str]]: + """ + Terragrunt version. + """ + return pulumi.get(self, "terragrunt_version") + + @terragrunt_version.setter + def terragrunt_version(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "terragrunt_version", value) + + @property + @pulumi.getter(name="useRunAll") + def use_run_all(self) -> Optional[pulumi.Input[bool]]: + """ + Whether to use `terragrunt run-all` instead of `terragrunt`. + """ + return pulumi.get(self, "use_run_all") + + @use_run_all.setter + def use_run_all(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "use_run_all", value) + + @property + @pulumi.getter(name="useSmartSanitization") + def use_smart_sanitization(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "use_smart_sanitization") + + @use_smart_sanitization.setter + def use_smart_sanitization(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "use_smart_sanitization", value) + + +@pulumi.input_type +class UserPolicyArgs: + def __init__(__self__, *, + role: pulumi.Input[str], + space_id: pulumi.Input[str]): + """ + :param pulumi.Input[str] role: Type of access to the space. Possible values are: READ, WRITE, ADMIN + :param pulumi.Input[str] space_id: ID (slug) of the space the user has access to + """ + UserPolicyArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + role=role, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + role: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if role is None: + raise TypeError("Missing 'role' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + + _setter("role", role) + _setter("space_id", space_id) + + @property + @pulumi.getter + def role(self) -> pulumi.Input[str]: + """ + Type of access to the space. Possible values are: READ, WRITE, ADMIN + """ + return pulumi.get(self, "role") + + @role.setter + def role(self, value: pulumi.Input[str]): + pulumi.set(self, "role", value) + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> pulumi.Input[str]: + """ + ID (slug) of the space the user has access to + """ + return pulumi.get(self, "space_id") + + @space_id.setter + def space_id(self, value: pulumi.Input[str]): + pulumi.set(self, "space_id", value) + + +@pulumi.input_type +class GetContextsLabelArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetContextsLabelArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksAdministrativeArgs: + def __init__(__self__, *, + equals: Optional[bool] = None): + GetStacksAdministrativeArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + equals=equals, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + equals: Optional[bool] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + + if equals is not None: + _setter("equals", equals) + + @property + @pulumi.getter + def equals(self) -> Optional[bool]: + return pulumi.get(self, "equals") + + @equals.setter + def equals(self, value: Optional[bool]): + pulumi.set(self, "equals", value) + + +@pulumi.input_type +class GetStacksBranchArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksBranchArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksCommitArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksCommitArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksLabelArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksLabelArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksLockedArgs: + def __init__(__self__, *, + equals: Optional[bool] = None): + GetStacksLockedArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + equals=equals, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + equals: Optional[bool] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + + if equals is not None: + _setter("equals", equals) + + @property + @pulumi.getter + def equals(self) -> Optional[bool]: + return pulumi.get(self, "equals") + + @equals.setter + def equals(self, value: Optional[bool]): + pulumi.set(self, "equals", value) + + +@pulumi.input_type +class GetStacksNameArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksNameArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksProjectRootArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksProjectRootArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksRepositoryArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksRepositoryArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksStateArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksStateArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksVendorArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksVendorArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + +@pulumi.input_type +class GetStacksWorkerPoolArgs: + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksWorkerPoolArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @any_ofs.setter + def any_ofs(self, value: Sequence[str]): + pulumi.set(self, "any_ofs", value) + + diff --git a/sdk/python/pulumi_spacelift/_utilities.py b/sdk/python/pulumi_spacelift/_utilities.py index 3e8578a..ce1ba37 100644 --- a/sdk/python/pulumi_spacelift/_utilities.py +++ b/sdk/python/pulumi_spacelift/_utilities.py @@ -246,5 +246,24 @@ def lifted_func(*args, opts=None, **kwargs): return (lambda _: lifted_func) + +def configure(val, cls: type, input: bool): + def _apply(v): + if isinstance(v, typing.Mapping): + def _setter(key, value): + v[key] = value + cls._configure(_setter, **v) + return v + + # Check that cls has a static _configure method. External classes may + # not have it if it was generated with older codegen. + if hasattr(cls, "_configure"): + if isinstance(val, typing.Mapping): + return _apply(val) + elif input and val is not None and not isinstance(val, cls): + return pulumi.Output.from_input(val).apply(_apply) + + return val + def get_plugin_download_url(): return "https://downloads.spacelift.io/pulumi-plugins" diff --git a/sdk/python/pulumi_spacelift/aws_integration.py b/sdk/python/pulumi_spacelift/aws_integration.py index 1ffe3ab..ece5bb4 100644 --- a/sdk/python/pulumi_spacelift/aws_integration.py +++ b/sdk/python/pulumi_spacelift/aws_integration.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['AwsIntegrationArgs', 'AwsIntegration'] @@ -31,19 +31,54 @@ def __init__(__self__, *, :param pulumi.Input[str] name: The friendly name of the integration :param pulumi.Input[str] space_id: ID (slug) of the space the integration is in """ - pulumi.set(__self__, "role_arn", role_arn) + AwsIntegrationArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + role_arn=role_arn, + duration_seconds=duration_seconds, + external_id=external_id, + generate_credentials_in_worker=generate_credentials_in_worker, + labels=labels, + name=name, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + role_arn: Optional[pulumi.Input[str]] = None, + duration_seconds: Optional[pulumi.Input[int]] = None, + external_id: Optional[pulumi.Input[str]] = None, + generate_credentials_in_worker: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if role_arn is None and 'roleArn' in kwargs: + role_arn = kwargs['roleArn'] + if role_arn is None: + raise TypeError("Missing 'role_arn' argument") + if duration_seconds is None and 'durationSeconds' in kwargs: + duration_seconds = kwargs['durationSeconds'] + if external_id is None and 'externalId' in kwargs: + external_id = kwargs['externalId'] + if generate_credentials_in_worker is None and 'generateCredentialsInWorker' in kwargs: + generate_credentials_in_worker = kwargs['generateCredentialsInWorker'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + + _setter("role_arn", role_arn) if duration_seconds is not None: - pulumi.set(__self__, "duration_seconds", duration_seconds) + _setter("duration_seconds", duration_seconds) if external_id is not None: - pulumi.set(__self__, "external_id", external_id) + _setter("external_id", external_id) if generate_credentials_in_worker is not None: - pulumi.set(__self__, "generate_credentials_in_worker", generate_credentials_in_worker) + _setter("generate_credentials_in_worker", generate_credentials_in_worker) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) @property @pulumi.getter(name="roleArn") @@ -150,20 +185,53 @@ def __init__(__self__, *, :param pulumi.Input[str] role_arn: ARN of the AWS IAM role to attach :param pulumi.Input[str] space_id: ID (slug) of the space the integration is in """ + _AwsIntegrationState._configure( + lambda key, value: pulumi.set(__self__, key, value), + duration_seconds=duration_seconds, + external_id=external_id, + generate_credentials_in_worker=generate_credentials_in_worker, + labels=labels, + name=name, + role_arn=role_arn, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + duration_seconds: Optional[pulumi.Input[int]] = None, + external_id: Optional[pulumi.Input[str]] = None, + generate_credentials_in_worker: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + role_arn: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if duration_seconds is None and 'durationSeconds' in kwargs: + duration_seconds = kwargs['durationSeconds'] + if external_id is None and 'externalId' in kwargs: + external_id = kwargs['externalId'] + if generate_credentials_in_worker is None and 'generateCredentialsInWorker' in kwargs: + generate_credentials_in_worker = kwargs['generateCredentialsInWorker'] + if role_arn is None and 'roleArn' in kwargs: + role_arn = kwargs['roleArn'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if duration_seconds is not None: - pulumi.set(__self__, "duration_seconds", duration_seconds) + _setter("duration_seconds", duration_seconds) if external_id is not None: - pulumi.set(__self__, "external_id", external_id) + _setter("external_id", external_id) if generate_credentials_in_worker is not None: - pulumi.set(__self__, "generate_credentials_in_worker", generate_credentials_in_worker) + _setter("generate_credentials_in_worker", generate_credentials_in_worker) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if role_arn is not None: - pulumi.set(__self__, "role_arn", role_arn) + _setter("role_arn", role_arn) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) @property @pulumi.getter(name="durationSeconds") @@ -266,7 +334,7 @@ def __init__(__self__, """ `AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. - Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-$suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@$suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. ## Import @@ -293,7 +361,7 @@ def __init__(__self__, """ `AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. - Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-$suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@$suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. ## Import @@ -311,6 +379,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + AwsIntegrationArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/aws_integration_attachment.py b/sdk/python/pulumi_spacelift/aws_integration_attachment.py index 135a778..8851af1 100644 --- a/sdk/python/pulumi_spacelift/aws_integration_attachment.py +++ b/sdk/python/pulumi_spacelift/aws_integration_attachment.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['AwsIntegrationAttachmentArgs', 'AwsIntegrationAttachment'] @@ -27,15 +27,42 @@ def __init__(__self__, *, :param pulumi.Input[str] stack_id: ID of the stack to attach the integration to :param pulumi.Input[bool] write: Indicates whether this attachment is used for write operations. Defaults to `true`. """ - pulumi.set(__self__, "integration_id", integration_id) + AwsIntegrationAttachmentArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + integration_id=integration_id, + module_id=module_id, + read=read, + stack_id=stack_id, + write=write, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + integration_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + read: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + write: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if integration_id is None and 'integrationId' in kwargs: + integration_id = kwargs['integrationId'] + if integration_id is None: + raise TypeError("Missing 'integration_id' argument") + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + _setter("integration_id", integration_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if read is not None: - pulumi.set(__self__, "read", read) + _setter("read", read) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if write is not None: - pulumi.set(__self__, "write", write) + _setter("write", write) @property @pulumi.getter(name="integrationId") @@ -116,18 +143,47 @@ def __init__(__self__, *, :param pulumi.Input[str] stack_id: ID of the stack to attach the integration to :param pulumi.Input[bool] write: Indicates whether this attachment is used for write operations. Defaults to `true`. """ + _AwsIntegrationAttachmentState._configure( + lambda key, value: pulumi.set(__self__, key, value), + attachment_id=attachment_id, + integration_id=integration_id, + module_id=module_id, + read=read, + stack_id=stack_id, + write=write, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + attachment_id: Optional[pulumi.Input[str]] = None, + integration_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + read: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + write: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if attachment_id is None and 'attachmentId' in kwargs: + attachment_id = kwargs['attachmentId'] + if integration_id is None and 'integrationId' in kwargs: + integration_id = kwargs['integrationId'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if attachment_id is not None: - pulumi.set(__self__, "attachment_id", attachment_id) + _setter("attachment_id", attachment_id) if integration_id is not None: - pulumi.set(__self__, "integration_id", integration_id) + _setter("integration_id", integration_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if read is not None: - pulumi.set(__self__, "read", read) + _setter("read", read) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if write is not None: - pulumi.set(__self__, "write", write) + _setter("write", write) @property @pulumi.getter(name="attachmentId") @@ -299,6 +355,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + AwsIntegrationAttachmentArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/aws_role.py b/sdk/python/pulumi_spacelift/aws_role.py index bb14052..af1e1f5 100644 --- a/sdk/python/pulumi_spacelift/aws_role.py +++ b/sdk/python/pulumi_spacelift/aws_role.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['AwsRoleArgs', 'AwsRole'] @@ -29,17 +29,52 @@ def __init__(__self__, *, :param pulumi.Input[str] module_id: ID of the module which assumes the AWS IAM role :param pulumi.Input[str] stack_id: ID of the stack which assumes the AWS IAM role """ - pulumi.set(__self__, "role_arn", role_arn) + AwsRoleArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + role_arn=role_arn, + duration_seconds=duration_seconds, + external_id=external_id, + generate_credentials_in_worker=generate_credentials_in_worker, + module_id=module_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + role_arn: Optional[pulumi.Input[str]] = None, + duration_seconds: Optional[pulumi.Input[int]] = None, + external_id: Optional[pulumi.Input[str]] = None, + generate_credentials_in_worker: Optional[pulumi.Input[bool]] = None, + module_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if role_arn is None and 'roleArn' in kwargs: + role_arn = kwargs['roleArn'] + if role_arn is None: + raise TypeError("Missing 'role_arn' argument") + if duration_seconds is None and 'durationSeconds' in kwargs: + duration_seconds = kwargs['durationSeconds'] + if external_id is None and 'externalId' in kwargs: + external_id = kwargs['externalId'] + if generate_credentials_in_worker is None and 'generateCredentialsInWorker' in kwargs: + generate_credentials_in_worker = kwargs['generateCredentialsInWorker'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + _setter("role_arn", role_arn) if duration_seconds is not None: - pulumi.set(__self__, "duration_seconds", duration_seconds) + _setter("duration_seconds", duration_seconds) if external_id is not None: - pulumi.set(__self__, "external_id", external_id) + _setter("external_id", external_id) if generate_credentials_in_worker is not None: - pulumi.set(__self__, "generate_credentials_in_worker", generate_credentials_in_worker) + _setter("generate_credentials_in_worker", generate_credentials_in_worker) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="roleArn") @@ -132,18 +167,51 @@ def __init__(__self__, *, :param pulumi.Input[str] role_arn: ARN of the AWS IAM role to attach :param pulumi.Input[str] stack_id: ID of the stack which assumes the AWS IAM role """ + _AwsRoleState._configure( + lambda key, value: pulumi.set(__self__, key, value), + duration_seconds=duration_seconds, + external_id=external_id, + generate_credentials_in_worker=generate_credentials_in_worker, + module_id=module_id, + role_arn=role_arn, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + duration_seconds: Optional[pulumi.Input[int]] = None, + external_id: Optional[pulumi.Input[str]] = None, + generate_credentials_in_worker: Optional[pulumi.Input[bool]] = None, + module_id: Optional[pulumi.Input[str]] = None, + role_arn: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if duration_seconds is None and 'durationSeconds' in kwargs: + duration_seconds = kwargs['durationSeconds'] + if external_id is None and 'externalId' in kwargs: + external_id = kwargs['externalId'] + if generate_credentials_in_worker is None and 'generateCredentialsInWorker' in kwargs: + generate_credentials_in_worker = kwargs['generateCredentialsInWorker'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if role_arn is None and 'roleArn' in kwargs: + role_arn = kwargs['roleArn'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if duration_seconds is not None: - pulumi.set(__self__, "duration_seconds", duration_seconds) + _setter("duration_seconds", duration_seconds) if external_id is not None: - pulumi.set(__self__, "external_id", external_id) + _setter("external_id", external_id) if generate_credentials_in_worker is not None: - pulumi.set(__self__, "generate_credentials_in_worker", generate_credentials_in_worker) + _setter("generate_credentials_in_worker", generate_credentials_in_worker) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if role_arn is not None: - pulumi.set(__self__, "role_arn", role_arn) + _setter("role_arn", role_arn) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="durationSeconds") @@ -293,6 +361,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + AwsRoleArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/azure_integration.py b/sdk/python/pulumi_spacelift/azure_integration.py index e784adb..fa4ea19 100644 --- a/sdk/python/pulumi_spacelift/azure_integration.py +++ b/sdk/python/pulumi_spacelift/azure_integration.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['AzureIntegrationArgs', 'AzureIntegration'] @@ -27,15 +27,42 @@ def __init__(__self__, *, :param pulumi.Input[str] name: The friendly name of the integration :param pulumi.Input[str] space_id: ID (slug) of the space the integration is in """ - pulumi.set(__self__, "tenant_id", tenant_id) + AzureIntegrationArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + tenant_id=tenant_id, + default_subscription_id=default_subscription_id, + labels=labels, + name=name, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + tenant_id: Optional[pulumi.Input[str]] = None, + default_subscription_id: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if tenant_id is None and 'tenantId' in kwargs: + tenant_id = kwargs['tenantId'] + if tenant_id is None: + raise TypeError("Missing 'tenant_id' argument") + if default_subscription_id is None and 'defaultSubscriptionId' in kwargs: + default_subscription_id = kwargs['defaultSubscriptionId'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + + _setter("tenant_id", tenant_id) if default_subscription_id is not None: - pulumi.set(__self__, "default_subscription_id", default_subscription_id) + _setter("default_subscription_id", default_subscription_id) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) @property @pulumi.getter(name="tenantId") @@ -122,24 +149,65 @@ def __init__(__self__, *, :param pulumi.Input[str] space_id: ID (slug) of the space the integration is in :param pulumi.Input[str] tenant_id: The Azure AD tenant ID """ + _AzureIntegrationState._configure( + lambda key, value: pulumi.set(__self__, key, value), + admin_consent_provided=admin_consent_provided, + admin_consent_url=admin_consent_url, + application_id=application_id, + default_subscription_id=default_subscription_id, + display_name=display_name, + labels=labels, + name=name, + space_id=space_id, + tenant_id=tenant_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + admin_consent_provided: Optional[pulumi.Input[bool]] = None, + admin_consent_url: Optional[pulumi.Input[str]] = None, + application_id: Optional[pulumi.Input[str]] = None, + default_subscription_id: Optional[pulumi.Input[str]] = None, + display_name: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + tenant_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if admin_consent_provided is None and 'adminConsentProvided' in kwargs: + admin_consent_provided = kwargs['adminConsentProvided'] + if admin_consent_url is None and 'adminConsentUrl' in kwargs: + admin_consent_url = kwargs['adminConsentUrl'] + if application_id is None and 'applicationId' in kwargs: + application_id = kwargs['applicationId'] + if default_subscription_id is None and 'defaultSubscriptionId' in kwargs: + default_subscription_id = kwargs['defaultSubscriptionId'] + if display_name is None and 'displayName' in kwargs: + display_name = kwargs['displayName'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if tenant_id is None and 'tenantId' in kwargs: + tenant_id = kwargs['tenantId'] + if admin_consent_provided is not None: - pulumi.set(__self__, "admin_consent_provided", admin_consent_provided) + _setter("admin_consent_provided", admin_consent_provided) if admin_consent_url is not None: - pulumi.set(__self__, "admin_consent_url", admin_consent_url) + _setter("admin_consent_url", admin_consent_url) if application_id is not None: - pulumi.set(__self__, "application_id", application_id) + _setter("application_id", application_id) if default_subscription_id is not None: - pulumi.set(__self__, "default_subscription_id", default_subscription_id) + _setter("default_subscription_id", default_subscription_id) if display_name is not None: - pulumi.set(__self__, "display_name", display_name) + _setter("display_name", display_name) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) if tenant_id is not None: - pulumi.set(__self__, "tenant_id", tenant_id) + _setter("tenant_id", tenant_id) @property @pulumi.getter(name="adminConsentProvided") @@ -333,6 +401,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + AzureIntegrationArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/azure_integration_attachment.py b/sdk/python/pulumi_spacelift/azure_integration_attachment.py index 97bc5fc..3f693fb 100644 --- a/sdk/python/pulumi_spacelift/azure_integration_attachment.py +++ b/sdk/python/pulumi_spacelift/azure_integration_attachment.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['AzureIntegrationAttachmentArgs', 'AzureIntegrationAttachment'] @@ -29,17 +29,48 @@ def __init__(__self__, *, :param pulumi.Input[str] subscription_id: Contains the Azure subscription ID to use with this Stack. Overrides the default subscription ID set at the integration level. :param pulumi.Input[bool] write: Indicates whether this attachment is used for write operations. Defaults to `true`. """ - pulumi.set(__self__, "integration_id", integration_id) + AzureIntegrationAttachmentArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + integration_id=integration_id, + module_id=module_id, + read=read, + stack_id=stack_id, + subscription_id=subscription_id, + write=write, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + integration_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + read: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + subscription_id: Optional[pulumi.Input[str]] = None, + write: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if integration_id is None and 'integrationId' in kwargs: + integration_id = kwargs['integrationId'] + if integration_id is None: + raise TypeError("Missing 'integration_id' argument") + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if subscription_id is None and 'subscriptionId' in kwargs: + subscription_id = kwargs['subscriptionId'] + + _setter("integration_id", integration_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if read is not None: - pulumi.set(__self__, "read", read) + _setter("read", read) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if subscription_id is not None: - pulumi.set(__self__, "subscription_id", subscription_id) + _setter("subscription_id", subscription_id) if write is not None: - pulumi.set(__self__, "write", write) + _setter("write", write) @property @pulumi.getter(name="integrationId") @@ -134,20 +165,53 @@ def __init__(__self__, *, :param pulumi.Input[str] subscription_id: Contains the Azure subscription ID to use with this Stack. Overrides the default subscription ID set at the integration level. :param pulumi.Input[bool] write: Indicates whether this attachment is used for write operations. Defaults to `true`. """ + _AzureIntegrationAttachmentState._configure( + lambda key, value: pulumi.set(__self__, key, value), + attachment_id=attachment_id, + integration_id=integration_id, + module_id=module_id, + read=read, + stack_id=stack_id, + subscription_id=subscription_id, + write=write, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + attachment_id: Optional[pulumi.Input[str]] = None, + integration_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + read: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + subscription_id: Optional[pulumi.Input[str]] = None, + write: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if attachment_id is None and 'attachmentId' in kwargs: + attachment_id = kwargs['attachmentId'] + if integration_id is None and 'integrationId' in kwargs: + integration_id = kwargs['integrationId'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if subscription_id is None and 'subscriptionId' in kwargs: + subscription_id = kwargs['subscriptionId'] + if attachment_id is not None: - pulumi.set(__self__, "attachment_id", attachment_id) + _setter("attachment_id", attachment_id) if integration_id is not None: - pulumi.set(__self__, "integration_id", integration_id) + _setter("integration_id", integration_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if read is not None: - pulumi.set(__self__, "read", read) + _setter("read", read) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if subscription_id is not None: - pulumi.set(__self__, "subscription_id", subscription_id) + _setter("subscription_id", subscription_id) if write is not None: - pulumi.set(__self__, "write", write) + _setter("write", write) @property @pulumi.getter(name="attachmentId") @@ -337,6 +401,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + AzureIntegrationAttachmentArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/blueprint.py b/sdk/python/pulumi_spacelift/blueprint.py new file mode 100644 index 0000000..b3f43c3 --- /dev/null +++ b/sdk/python/pulumi_spacelift/blueprint.py @@ -0,0 +1,430 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['BlueprintArgs', 'Blueprint'] + +@pulumi.input_type +class BlueprintArgs: + def __init__(__self__, *, + space: pulumi.Input[str], + state: pulumi.Input[str], + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + template: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a Blueprint resource. + :param pulumi.Input[str] space: ID of the space the blueprint is in + :param pulumi.Input[str] state: State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + :param pulumi.Input[str] description: Description of the blueprint + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: Labels of the blueprint + :param pulumi.Input[str] name: Name of the blueprint + :param pulumi.Input[str] template: Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + """ + BlueprintArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + space=space, + state=state, + description=description, + labels=labels, + name=name, + template=template, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + space: Optional[pulumi.Input[str]] = None, + state: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + template: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if space is None: + raise TypeError("Missing 'space' argument") + if state is None: + raise TypeError("Missing 'state' argument") + + _setter("space", space) + _setter("state", state) + if description is not None: + _setter("description", description) + if labels is not None: + _setter("labels", labels) + if name is not None: + _setter("name", name) + if template is not None: + _setter("template", template) + + @property + @pulumi.getter + def space(self) -> pulumi.Input[str]: + """ + ID of the space the blueprint is in + """ + return pulumi.get(self, "space") + + @space.setter + def space(self, value: pulumi.Input[str]): + pulumi.set(self, "space", value) + + @property + @pulumi.getter + def state(self) -> pulumi.Input[str]: + """ + State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + """ + return pulumi.get(self, "state") + + @state.setter + def state(self, value: pulumi.Input[str]): + pulumi.set(self, "state", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + """ + Description of the blueprint + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + """ + Labels of the blueprint + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + """ + Name of the blueprint + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def template(self) -> Optional[pulumi.Input[str]]: + """ + Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + """ + return pulumi.get(self, "template") + + @template.setter + def template(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "template", value) + + +@pulumi.input_type +class _BlueprintState: + def __init__(__self__, *, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space: Optional[pulumi.Input[str]] = None, + state: Optional[pulumi.Input[str]] = None, + template: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering Blueprint resources. + :param pulumi.Input[str] description: Description of the blueprint + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: Labels of the blueprint + :param pulumi.Input[str] name: Name of the blueprint + :param pulumi.Input[str] space: ID of the space the blueprint is in + :param pulumi.Input[str] state: State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + :param pulumi.Input[str] template: Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + """ + _BlueprintState._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + labels=labels, + name=name, + space=space, + state=state, + template=template, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space: Optional[pulumi.Input[str]] = None, + state: Optional[pulumi.Input[str]] = None, + template: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + + if description is not None: + _setter("description", description) + if labels is not None: + _setter("labels", labels) + if name is not None: + _setter("name", name) + if space is not None: + _setter("space", space) + if state is not None: + _setter("state", state) + if template is not None: + _setter("template", template) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + """ + Description of the blueprint + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + """ + Labels of the blueprint + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + """ + Name of the blueprint + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def space(self) -> Optional[pulumi.Input[str]]: + """ + ID of the space the blueprint is in + """ + return pulumi.get(self, "space") + + @space.setter + def space(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "space", value) + + @property + @pulumi.getter + def state(self) -> Optional[pulumi.Input[str]]: + """ + State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + """ + return pulumi.get(self, "state") + + @state.setter + def state(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "state", value) + + @property + @pulumi.getter + def template(self) -> Optional[pulumi.Input[str]]: + """ + Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + """ + return pulumi.get(self, "template") + + @template.setter + def template(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "template", value) + + +class Blueprint(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space: Optional[pulumi.Input[str]] = None, + state: Optional[pulumi.Input[str]] = None, + template: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a Blueprint resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] description: Description of the blueprint + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: Labels of the blueprint + :param pulumi.Input[str] name: Name of the blueprint + :param pulumi.Input[str] space: ID of the space the blueprint is in + :param pulumi.Input[str] state: State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + :param pulumi.Input[str] template: Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: BlueprintArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Blueprint resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param BlueprintArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(BlueprintArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + BlueprintArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space: Optional[pulumi.Input[str]] = None, + state: Optional[pulumi.Input[str]] = None, + template: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = BlueprintArgs.__new__(BlueprintArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + if space is None and not opts.urn: + raise TypeError("Missing required property 'space'") + __props__.__dict__["space"] = space + if state is None and not opts.urn: + raise TypeError("Missing required property 'state'") + __props__.__dict__["state"] = state + __props__.__dict__["template"] = template + super(Blueprint, __self__).__init__( + 'spacelift:index/blueprint:Blueprint', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space: Optional[pulumi.Input[str]] = None, + state: Optional[pulumi.Input[str]] = None, + template: Optional[pulumi.Input[str]] = None) -> 'Blueprint': + """ + Get an existing Blueprint resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] description: Description of the blueprint + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: Labels of the blueprint + :param pulumi.Input[str] name: Name of the blueprint + :param pulumi.Input[str] space: ID of the space the blueprint is in + :param pulumi.Input[str] state: State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + :param pulumi.Input[str] template: Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _BlueprintState.__new__(_BlueprintState) + + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["space"] = space + __props__.__dict__["state"] = state + __props__.__dict__["template"] = template + return Blueprint(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + """ + Description of the blueprint + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Sequence[str]]]: + """ + Labels of the blueprint + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + """ + Name of the blueprint + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def space(self) -> pulumi.Output[str]: + """ + ID of the space the blueprint is in + """ + return pulumi.get(self, "space") + + @property + @pulumi.getter + def state(self) -> pulumi.Output[str]: + """ + State of the blueprint. Value can be `DRAFT` or `PUBLISHED`. + """ + return pulumi.get(self, "state") + + @property + @pulumi.getter + def template(self) -> pulumi.Output[Optional[str]]: + """ + Body of the blueprint. If `state` is set to `PUBLISHED`, this field is required. + """ + return pulumi.get(self, "template") + diff --git a/sdk/python/pulumi_spacelift/config/__init__.pyi b/sdk/python/pulumi_spacelift/config/__init__.pyi index 54d0c8b..66f33db 100644 --- a/sdk/python/pulumi_spacelift/config/__init__.pyi +++ b/sdk/python/pulumi_spacelift/config/__init__.pyi @@ -6,7 +6,7 @@ import copy import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from .. import _utilities apiKeyEndpoint: Optional[str] diff --git a/sdk/python/pulumi_spacelift/config/vars.py b/sdk/python/pulumi_spacelift/config/vars.py index b097937..aee3d6a 100644 --- a/sdk/python/pulumi_spacelift/config/vars.py +++ b/sdk/python/pulumi_spacelift/config/vars.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from .. import _utilities import types diff --git a/sdk/python/pulumi_spacelift/context.py b/sdk/python/pulumi_spacelift/context.py index 7b843ce..1b881fb 100644 --- a/sdk/python/pulumi_spacelift/context.py +++ b/sdk/python/pulumi_spacelift/context.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['ContextArgs', 'Context'] @@ -24,14 +24,33 @@ def __init__(__self__, *, :param pulumi.Input[str] name: Name of the context - should be unique in one account :param pulumi.Input[str] space_id: ID (slug) of the space the context is in """ + ContextArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + labels=labels, + name=name, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) @property @pulumi.getter @@ -92,14 +111,33 @@ def __init__(__self__, *, :param pulumi.Input[str] name: Name of the context - should be unique in one account :param pulumi.Input[str] space_id: ID (slug) of the space the context is in """ + _ContextState._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + labels=labels, + name=name, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) @property @pulumi.getter @@ -215,6 +253,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + ContextArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/context_attachment.py b/sdk/python/pulumi_spacelift/context_attachment.py index e392841..d84218a 100644 --- a/sdk/python/pulumi_spacelift/context_attachment.py +++ b/sdk/python/pulumi_spacelift/context_attachment.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['ContextAttachmentArgs', 'ContextAttachment'] @@ -25,13 +25,38 @@ def __init__(__self__, *, :param pulumi.Input[int] priority: Priority of the context attachment. All the contexts attached to a stack are sorted by priority (lowest first), though values don't need to be unique. This ordering establishes precedence rules between contexts should there be a conflict and multiple contexts define the same value. Defaults to `0`. :param pulumi.Input[str] stack_id: ID of the stack to attach the context to """ - pulumi.set(__self__, "context_id", context_id) + ContextAttachmentArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + context_id=context_id, + module_id=module_id, + priority=priority, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + context_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + priority: Optional[pulumi.Input[int]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if context_id is None and 'contextId' in kwargs: + context_id = kwargs['contextId'] + if context_id is None: + raise TypeError("Missing 'context_id' argument") + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + _setter("context_id", context_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if priority is not None: - pulumi.set(__self__, "priority", priority) + _setter("priority", priority) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="contextId") @@ -96,14 +121,37 @@ def __init__(__self__, *, :param pulumi.Input[int] priority: Priority of the context attachment. All the contexts attached to a stack are sorted by priority (lowest first), though values don't need to be unique. This ordering establishes precedence rules between contexts should there be a conflict and multiple contexts define the same value. Defaults to `0`. :param pulumi.Input[str] stack_id: ID of the stack to attach the context to """ + _ContextAttachmentState._configure( + lambda key, value: pulumi.set(__self__, key, value), + context_id=context_id, + module_id=module_id, + priority=priority, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + context_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + priority: Optional[pulumi.Input[int]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if context_id is None and 'contextId' in kwargs: + context_id = kwargs['contextId'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if context_id is not None: - pulumi.set(__self__, "context_id", context_id) + _setter("context_id", context_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if priority is not None: - pulumi.set(__self__, "priority", priority) + _setter("priority", priority) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="contextId") @@ -231,6 +279,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + ContextAttachmentArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/drift_detection.py b/sdk/python/pulumi_spacelift/drift_detection.py index b055008..458c815 100644 --- a/sdk/python/pulumi_spacelift/drift_detection.py +++ b/sdk/python/pulumi_spacelift/drift_detection.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['DriftDetectionArgs', 'DriftDetection'] @@ -16,21 +16,52 @@ class DriftDetectionArgs: def __init__(__self__, *, schedules: pulumi.Input[Sequence[pulumi.Input[str]]], stack_id: pulumi.Input[str], + ignore_state: Optional[pulumi.Input[bool]] = None, reconcile: Optional[pulumi.Input[bool]] = None, timezone: Optional[pulumi.Input[str]] = None): """ The set of arguments for constructing a DriftDetection resource. :param pulumi.Input[Sequence[pulumi.Input[str]]] schedules: List of cron schedule expressions based on which drift detection should be triggered. :param pulumi.Input[str] stack_id: ID of the stack for which to set up drift detection + :param pulumi.Input[bool] ignore_state: Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. :param pulumi.Input[bool] reconcile: Whether a tracked run should be triggered when drift is detected. :param pulumi.Input[str] timezone: Timezone in which the schedule is expressed. Defaults to `UTC`. """ - pulumi.set(__self__, "schedules", schedules) - pulumi.set(__self__, "stack_id", stack_id) + DriftDetectionArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + schedules=schedules, + stack_id=stack_id, + ignore_state=ignore_state, + reconcile=reconcile, + timezone=timezone, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + schedules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + ignore_state: Optional[pulumi.Input[bool]] = None, + reconcile: Optional[pulumi.Input[bool]] = None, + timezone: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if schedules is None: + raise TypeError("Missing 'schedules' argument") + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if stack_id is None: + raise TypeError("Missing 'stack_id' argument") + if ignore_state is None and 'ignoreState' in kwargs: + ignore_state = kwargs['ignoreState'] + + _setter("schedules", schedules) + _setter("stack_id", stack_id) + if ignore_state is not None: + _setter("ignore_state", ignore_state) if reconcile is not None: - pulumi.set(__self__, "reconcile", reconcile) + _setter("reconcile", reconcile) if timezone is not None: - pulumi.set(__self__, "timezone", timezone) + _setter("timezone", timezone) @property @pulumi.getter @@ -56,6 +87,18 @@ def stack_id(self) -> pulumi.Input[str]: def stack_id(self, value: pulumi.Input[str]): pulumi.set(self, "stack_id", value) + @property + @pulumi.getter(name="ignoreState") + def ignore_state(self) -> Optional[pulumi.Input[bool]]: + """ + Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + """ + return pulumi.get(self, "ignore_state") + + @ignore_state.setter + def ignore_state(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "ignore_state", value) + @property @pulumi.getter def reconcile(self) -> Optional[pulumi.Input[bool]]: @@ -84,25 +127,64 @@ def timezone(self, value: Optional[pulumi.Input[str]]): @pulumi.input_type class _DriftDetectionState: def __init__(__self__, *, + ignore_state: Optional[pulumi.Input[bool]] = None, reconcile: Optional[pulumi.Input[bool]] = None, schedules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, stack_id: Optional[pulumi.Input[str]] = None, timezone: Optional[pulumi.Input[str]] = None): """ Input properties used for looking up and filtering DriftDetection resources. + :param pulumi.Input[bool] ignore_state: Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. :param pulumi.Input[bool] reconcile: Whether a tracked run should be triggered when drift is detected. :param pulumi.Input[Sequence[pulumi.Input[str]]] schedules: List of cron schedule expressions based on which drift detection should be triggered. :param pulumi.Input[str] stack_id: ID of the stack for which to set up drift detection :param pulumi.Input[str] timezone: Timezone in which the schedule is expressed. Defaults to `UTC`. """ + _DriftDetectionState._configure( + lambda key, value: pulumi.set(__self__, key, value), + ignore_state=ignore_state, + reconcile=reconcile, + schedules=schedules, + stack_id=stack_id, + timezone=timezone, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + ignore_state: Optional[pulumi.Input[bool]] = None, + reconcile: Optional[pulumi.Input[bool]] = None, + schedules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + timezone: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if ignore_state is None and 'ignoreState' in kwargs: + ignore_state = kwargs['ignoreState'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + if ignore_state is not None: + _setter("ignore_state", ignore_state) if reconcile is not None: - pulumi.set(__self__, "reconcile", reconcile) + _setter("reconcile", reconcile) if schedules is not None: - pulumi.set(__self__, "schedules", schedules) + _setter("schedules", schedules) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if timezone is not None: - pulumi.set(__self__, "timezone", timezone) + _setter("timezone", timezone) + + @property + @pulumi.getter(name="ignoreState") + def ignore_state(self) -> Optional[pulumi.Input[bool]]: + """ + Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + """ + return pulumi.get(self, "ignore_state") + + @ignore_state.setter + def ignore_state(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "ignore_state", value) @property @pulumi.getter @@ -158,6 +240,7 @@ class DriftDetection(pulumi.CustomResource): def __init__(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, + ignore_state: Optional[pulumi.Input[bool]] = None, reconcile: Optional[pulumi.Input[bool]] = None, schedules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, stack_id: Optional[pulumi.Input[str]] = None, @@ -194,6 +277,7 @@ def __init__(__self__, :param str resource_name: The name of the resource. :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[bool] ignore_state: Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. :param pulumi.Input[bool] reconcile: Whether a tracked run should be triggered when drift is detected. :param pulumi.Input[Sequence[pulumi.Input[str]]] schedules: List of cron schedule expressions based on which drift detection should be triggered. :param pulumi.Input[str] stack_id: ID of the stack for which to set up drift detection @@ -244,11 +328,16 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + DriftDetectionArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, + ignore_state: Optional[pulumi.Input[bool]] = None, reconcile: Optional[pulumi.Input[bool]] = None, schedules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, stack_id: Optional[pulumi.Input[str]] = None, @@ -262,6 +351,7 @@ def _internal_init(__self__, raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') __props__ = DriftDetectionArgs.__new__(DriftDetectionArgs) + __props__.__dict__["ignore_state"] = ignore_state __props__.__dict__["reconcile"] = reconcile if schedules is None and not opts.urn: raise TypeError("Missing required property 'schedules'") @@ -280,6 +370,7 @@ def _internal_init(__self__, def get(resource_name: str, id: pulumi.Input[str], opts: Optional[pulumi.ResourceOptions] = None, + ignore_state: Optional[pulumi.Input[bool]] = None, reconcile: Optional[pulumi.Input[bool]] = None, schedules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, stack_id: Optional[pulumi.Input[str]] = None, @@ -291,6 +382,7 @@ def get(resource_name: str, :param str resource_name: The unique name of the resulting resource. :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[bool] ignore_state: Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. :param pulumi.Input[bool] reconcile: Whether a tracked run should be triggered when drift is detected. :param pulumi.Input[Sequence[pulumi.Input[str]]] schedules: List of cron schedule expressions based on which drift detection should be triggered. :param pulumi.Input[str] stack_id: ID of the stack for which to set up drift detection @@ -300,12 +392,21 @@ def get(resource_name: str, __props__ = _DriftDetectionState.__new__(_DriftDetectionState) + __props__.__dict__["ignore_state"] = ignore_state __props__.__dict__["reconcile"] = reconcile __props__.__dict__["schedules"] = schedules __props__.__dict__["stack_id"] = stack_id __props__.__dict__["timezone"] = timezone return DriftDetection(resource_name, opts=opts, __props__=__props__) + @property + @pulumi.getter(name="ignoreState") + def ignore_state(self) -> pulumi.Output[Optional[bool]]: + """ + Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + """ + return pulumi.get(self, "ignore_state") + @property @pulumi.getter def reconcile(self) -> pulumi.Output[Optional[bool]]: diff --git a/sdk/python/pulumi_spacelift/environment_variable.py b/sdk/python/pulumi_spacelift/environment_variable.py index 8db3727..19cc7e1 100644 --- a/sdk/python/pulumi_spacelift/environment_variable.py +++ b/sdk/python/pulumi_spacelift/environment_variable.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['EnvironmentVariableArgs', 'EnvironmentVariable'] @@ -14,44 +14,62 @@ @pulumi.input_type class EnvironmentVariableArgs: def __init__(__self__, *, - value: pulumi.Input[str], context_id: Optional[pulumi.Input[str]] = None, module_id: Optional[pulumi.Input[str]] = None, name: Optional[pulumi.Input[str]] = None, stack_id: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, write_only: Optional[pulumi.Input[bool]] = None): """ The set of arguments for constructing a EnvironmentVariable resource. - :param pulumi.Input[str] value: Value of the environment variable :param pulumi.Input[str] context_id: ID of the context on which the environment variable is defined :param pulumi.Input[str] module_id: ID of the module on which the environment variable is defined :param pulumi.Input[str] name: Name of the environment variable :param pulumi.Input[str] stack_id: ID of the stack on which the environment variable is defined - :param pulumi.Input[bool] write_only: Indicates whether the value can be read back outside a Run. Defaults to `true`. - """ - pulumi.set(__self__, "value", value) + :param pulumi.Input[str] value: Value of the environment variable. Defaults to an empty string. + :param pulumi.Input[bool] write_only: Indicates whether the value is secret or not. Defaults to `true`. + """ + EnvironmentVariableArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + context_id=context_id, + module_id=module_id, + name=name, + stack_id=stack_id, + value=value, + write_only=write_only, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + context_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, + write_only: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if context_id is None and 'contextId' in kwargs: + context_id = kwargs['contextId'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if write_only is None and 'writeOnly' in kwargs: + write_only = kwargs['writeOnly'] + if context_id is not None: - pulumi.set(__self__, "context_id", context_id) + _setter("context_id", context_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) + if value is not None: + _setter("value", value) if write_only is not None: - pulumi.set(__self__, "write_only", write_only) - - @property - @pulumi.getter - def value(self) -> pulumi.Input[str]: - """ - Value of the environment variable - """ - return pulumi.get(self, "value") - - @value.setter - def value(self, value: pulumi.Input[str]): - pulumi.set(self, "value", value) + _setter("write_only", write_only) @property @pulumi.getter(name="contextId") @@ -101,11 +119,23 @@ def stack_id(self) -> Optional[pulumi.Input[str]]: def stack_id(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "stack_id", value) + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[str]]: + """ + Value of the environment variable. Defaults to an empty string. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "value", value) + @property @pulumi.getter(name="writeOnly") def write_only(self) -> Optional[pulumi.Input[bool]]: """ - Indicates whether the value can be read back outside a Run. Defaults to `true`. + Indicates whether the value is secret or not. Defaults to `true`. """ return pulumi.get(self, "write_only") @@ -131,23 +161,54 @@ def __init__(__self__, *, :param pulumi.Input[str] module_id: ID of the module on which the environment variable is defined :param pulumi.Input[str] name: Name of the environment variable :param pulumi.Input[str] stack_id: ID of the stack on which the environment variable is defined - :param pulumi.Input[str] value: Value of the environment variable - :param pulumi.Input[bool] write_only: Indicates whether the value can be read back outside a Run. Defaults to `true`. - """ + :param pulumi.Input[str] value: Value of the environment variable. Defaults to an empty string. + :param pulumi.Input[bool] write_only: Indicates whether the value is secret or not. Defaults to `true`. + """ + _EnvironmentVariableState._configure( + lambda key, value: pulumi.set(__self__, key, value), + checksum=checksum, + context_id=context_id, + module_id=module_id, + name=name, + stack_id=stack_id, + value=value, + write_only=write_only, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + checksum: Optional[pulumi.Input[str]] = None, + context_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, + write_only: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if context_id is None and 'contextId' in kwargs: + context_id = kwargs['contextId'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if write_only is None and 'writeOnly' in kwargs: + write_only = kwargs['writeOnly'] + if checksum is not None: - pulumi.set(__self__, "checksum", checksum) + _setter("checksum", checksum) if context_id is not None: - pulumi.set(__self__, "context_id", context_id) + _setter("context_id", context_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if value is not None: - pulumi.set(__self__, "value", value) + _setter("value", value) if write_only is not None: - pulumi.set(__self__, "write_only", write_only) + _setter("write_only", write_only) @property @pulumi.getter @@ -213,7 +274,7 @@ def stack_id(self, value: Optional[pulumi.Input[str]]): @pulumi.getter def value(self) -> Optional[pulumi.Input[str]]: """ - Value of the environment variable + Value of the environment variable. Defaults to an empty string. """ return pulumi.get(self, "value") @@ -225,7 +286,7 @@ def value(self, value: Optional[pulumi.Input[str]]): @pulumi.getter(name="writeOnly") def write_only(self) -> Optional[pulumi.Input[bool]]: """ - Indicates whether the value can be read back outside a Run. Defaults to `true`. + Indicates whether the value is secret or not. Defaults to `true`. """ return pulumi.get(self, "write_only") @@ -292,14 +353,14 @@ def __init__(__self__, :param pulumi.Input[str] module_id: ID of the module on which the environment variable is defined :param pulumi.Input[str] name: Name of the environment variable :param pulumi.Input[str] stack_id: ID of the stack on which the environment variable is defined - :param pulumi.Input[str] value: Value of the environment variable - :param pulumi.Input[bool] write_only: Indicates whether the value can be read back outside a Run. Defaults to `true`. + :param pulumi.Input[str] value: Value of the environment variable. Defaults to an empty string. + :param pulumi.Input[bool] write_only: Indicates whether the value is secret or not. Defaults to `true`. """ ... @overload def __init__(__self__, resource_name: str, - args: EnvironmentVariableArgs, + args: Optional[EnvironmentVariableArgs] = None, opts: Optional[pulumi.ResourceOptions] = None): """ `EnvironmentVariable` defines an environment variable on the context (`Context`), stack (`Stack`) or a module (`Module`), thereby allowing to pass and share various secrets and configuration with Spacelift stacks. @@ -351,6 +412,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + EnvironmentVariableArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -375,11 +440,11 @@ def _internal_init(__self__, __props__.__dict__["module_id"] = module_id __props__.__dict__["name"] = name __props__.__dict__["stack_id"] = stack_id - if value is None and not opts.urn: - raise TypeError("Missing required property 'value'") - __props__.__dict__["value"] = value + __props__.__dict__["value"] = None if value is None else pulumi.Output.secret(value) __props__.__dict__["write_only"] = write_only __props__.__dict__["checksum"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["value"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) super(EnvironmentVariable, __self__).__init__( 'spacelift:index/environmentVariable:EnvironmentVariable', resource_name, @@ -409,8 +474,8 @@ def get(resource_name: str, :param pulumi.Input[str] module_id: ID of the module on which the environment variable is defined :param pulumi.Input[str] name: Name of the environment variable :param pulumi.Input[str] stack_id: ID of the stack on which the environment variable is defined - :param pulumi.Input[str] value: Value of the environment variable - :param pulumi.Input[bool] write_only: Indicates whether the value can be read back outside a Run. Defaults to `true`. + :param pulumi.Input[str] value: Value of the environment variable. Defaults to an empty string. + :param pulumi.Input[bool] write_only: Indicates whether the value is secret or not. Defaults to `true`. """ opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) @@ -467,9 +532,9 @@ def stack_id(self) -> pulumi.Output[Optional[str]]: @property @pulumi.getter - def value(self) -> pulumi.Output[str]: + def value(self) -> pulumi.Output[Optional[str]]: """ - Value of the environment variable + Value of the environment variable. Defaults to an empty string. """ return pulumi.get(self, "value") @@ -477,7 +542,7 @@ def value(self) -> pulumi.Output[str]: @pulumi.getter(name="writeOnly") def write_only(self) -> pulumi.Output[Optional[bool]]: """ - Indicates whether the value can be read back outside a Run. Defaults to `true`. + Indicates whether the value is secret or not. Defaults to `true`. """ return pulumi.get(self, "write_only") diff --git a/sdk/python/pulumi_spacelift/gcp_service_account.py b/sdk/python/pulumi_spacelift/gcp_service_account.py index d8693cd..abc9693 100644 --- a/sdk/python/pulumi_spacelift/gcp_service_account.py +++ b/sdk/python/pulumi_spacelift/gcp_service_account.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['GcpServiceAccountArgs', 'GcpServiceAccount'] @@ -23,11 +23,34 @@ def __init__(__self__, *, :param pulumi.Input[str] module_id: ID of the module which uses GCP service account credentials :param pulumi.Input[str] stack_id: ID of the stack which uses GCP service account credentials """ - pulumi.set(__self__, "token_scopes", token_scopes) + GcpServiceAccountArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + token_scopes=token_scopes, + module_id=module_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + token_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + module_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if token_scopes is None and 'tokenScopes' in kwargs: + token_scopes = kwargs['tokenScopes'] + if token_scopes is None: + raise TypeError("Missing 'token_scopes' argument") + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + _setter("token_scopes", token_scopes) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="tokenScopes") @@ -80,14 +103,39 @@ def __init__(__self__, *, :param pulumi.Input[str] stack_id: ID of the stack which uses GCP service account credentials :param pulumi.Input[Sequence[pulumi.Input[str]]] token_scopes: List of scopes that will be requested when generating temporary GCP service account credentials """ + _GcpServiceAccountState._configure( + lambda key, value: pulumi.set(__self__, key, value), + module_id=module_id, + service_account_email=service_account_email, + stack_id=stack_id, + token_scopes=token_scopes, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + module_id: Optional[pulumi.Input[str]] = None, + service_account_email: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + token_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if service_account_email is None and 'serviceAccountEmail' in kwargs: + service_account_email = kwargs['serviceAccountEmail'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if token_scopes is None and 'tokenScopes' in kwargs: + token_scopes = kwargs['tokenScopes'] + if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if service_account_email is not None: - pulumi.set(__self__, "service_account_email", service_account_email) + _setter("service_account_email", service_account_email) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if token_scopes is not None: - pulumi.set(__self__, "token_scopes", token_scopes) + _setter("token_scopes", token_scopes) @property @pulumi.getter(name="moduleId") @@ -152,7 +200,7 @@ def __init__(__self__, ```python import pulumi - import pulumi_gcp as gcp + import pulumi_google as google import pulumi_spacelift as spacelift k8s_core_stack = spacelift.Stack("k8s-coreStack", @@ -165,13 +213,14 @@ def __init__(__self__, "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/devstorage.full_control", ]) - k8s_core_project = gcp.organizations.Project("k8s-coreProject", - project_id="unicorn-k8s-core", - org_id=var["gcp_organization_id"]) - k8s_core_iam_member = gcp.projects.IAMMember("k8s-coreIAMMember", - project=k8s_core_project.id, - role="roles/owner", - member=k8s_core_gcp_service_account.service_account_email.apply(lambda service_account_email: f"serviceAccount:{service_account_email}")) + k8s_coregoogle_project = google.index.Google_project("k8s-coregoogle_project", + name=Kubernetes code, + project_id=unicorn-k8s-core, + org_id=var.gcp_organization_id) + k8s_coregoogle_project_iam_member = google.index.Google_project_iam_member("k8s-coregoogle_project_iam_member", + project=k8s_coregoogle_project.id, + role=roles/owner, + member=fserviceAccount:{k8s_core_gcp_service_account.service_account_email}) ``` ## Import @@ -201,7 +250,7 @@ def __init__(__self__, ```python import pulumi - import pulumi_gcp as gcp + import pulumi_google as google import pulumi_spacelift as spacelift k8s_core_stack = spacelift.Stack("k8s-coreStack", @@ -214,13 +263,14 @@ def __init__(__self__, "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/devstorage.full_control", ]) - k8s_core_project = gcp.organizations.Project("k8s-coreProject", - project_id="unicorn-k8s-core", - org_id=var["gcp_organization_id"]) - k8s_core_iam_member = gcp.projects.IAMMember("k8s-coreIAMMember", - project=k8s_core_project.id, - role="roles/owner", - member=k8s_core_gcp_service_account.service_account_email.apply(lambda service_account_email: f"serviceAccount:{service_account_email}")) + k8s_coregoogle_project = google.index.Google_project("k8s-coregoogle_project", + name=Kubernetes code, + project_id=unicorn-k8s-core, + org_id=var.gcp_organization_id) + k8s_coregoogle_project_iam_member = google.index.Google_project_iam_member("k8s-coregoogle_project_iam_member", + project=k8s_coregoogle_project.id, + role=roles/owner, + member=fserviceAccount:{k8s_core_gcp_service_account.service_account_email}) ``` ## Import @@ -243,6 +293,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + GcpServiceAccountArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/get_account.py b/sdk/python/pulumi_spacelift/get_account.py index 3c5fc88..18675bf 100644 --- a/sdk/python/pulumi_spacelift/get_account.py +++ b/sdk/python/pulumi_spacelift/get_account.py @@ -6,13 +6,14 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ 'GetAccountResult', 'AwaitableGetAccountResult', 'get_account', + 'get_account_output', ] @pulumi.output_type @@ -97,7 +98,24 @@ def get_account(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetAcco __ret__ = pulumi.runtime.invoke('spacelift:index/getAccount:getAccount', __args__, opts=opts, typ=GetAccountResult).value return AwaitableGetAccountResult( - aws_account_id=__ret__.aws_account_id, - id=__ret__.id, - name=__ret__.name, - tier=__ret__.tier) + aws_account_id=pulumi.get(__ret__, 'aws_account_id'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + tier=pulumi.get(__ret__, 'tier')) + + +@_utilities.lift_output_func(get_account) +def get_account_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetAccountResult]: + """ + `get_account` represents the currently used Spacelift **account** + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + this = spacelift.get_account() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_aws_integration.py b/sdk/python/pulumi_spacelift/get_aws_integration.py index 0194e04..b6be94c 100644 --- a/sdk/python/pulumi_spacelift/get_aws_integration.py +++ b/sdk/python/pulumi_spacelift/get_aws_integration.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -143,7 +143,7 @@ def get_aws_integration(integration_id: Optional[str] = None, """ `AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. - Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. ## Example Usage @@ -165,15 +165,15 @@ def get_aws_integration(integration_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getAwsIntegration:getAwsIntegration', __args__, opts=opts, typ=GetAwsIntegrationResult).value return AwaitableGetAwsIntegrationResult( - duration_seconds=__ret__.duration_seconds, - external_id=__ret__.external_id, - generate_credentials_in_worker=__ret__.generate_credentials_in_worker, - id=__ret__.id, - integration_id=__ret__.integration_id, - labels=__ret__.labels, - name=__ret__.name, - role_arn=__ret__.role_arn, - space_id=__ret__.space_id) + duration_seconds=pulumi.get(__ret__, 'duration_seconds'), + external_id=pulumi.get(__ret__, 'external_id'), + generate_credentials_in_worker=pulumi.get(__ret__, 'generate_credentials_in_worker'), + id=pulumi.get(__ret__, 'id'), + integration_id=pulumi.get(__ret__, 'integration_id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + role_arn=pulumi.get(__ret__, 'role_arn'), + space_id=pulumi.get(__ret__, 'space_id')) @_utilities.lift_output_func(get_aws_integration) @@ -183,7 +183,7 @@ def get_aws_integration_output(integration_id: Optional[pulumi.Input[Optional[st """ `AwsIntegration` represents an integration with an AWS account. This integration is account-level and needs to be explicitly attached to individual stacks in order to take effect. - Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName-$integrationID@$stackID-suffix` or `$accountName-$integrationID@$moduleID-$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. + Note: when assuming credentials for **shared workers**, Spacelift will use `$accountName@$integrationID@$stackID@suffix` or `$accountName@$integrationID@$moduleID@$suffix` as [external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) and `$runID@$stackID@$accountName` truncated to 64 characters as [session ID](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole),$suffix will be `read` or `write`. ## Example Usage diff --git a/sdk/python/pulumi_spacelift/get_aws_integration_attachment.py b/sdk/python/pulumi_spacelift/get_aws_integration_attachment.py index f8a41c7..8518f02 100644 --- a/sdk/python/pulumi_spacelift/get_aws_integration_attachment.py +++ b/sdk/python/pulumi_spacelift/get_aws_integration_attachment.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -136,13 +136,13 @@ def get_aws_integration_attachment(integration_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getAwsIntegrationAttachment:getAwsIntegrationAttachment', __args__, opts=opts, typ=GetAwsIntegrationAttachmentResult).value return AwaitableGetAwsIntegrationAttachmentResult( - attachment_id=__ret__.attachment_id, - id=__ret__.id, - integration_id=__ret__.integration_id, - module_id=__ret__.module_id, - read=__ret__.read, - stack_id=__ret__.stack_id, - write=__ret__.write) + attachment_id=pulumi.get(__ret__, 'attachment_id'), + id=pulumi.get(__ret__, 'id'), + integration_id=pulumi.get(__ret__, 'integration_id'), + module_id=pulumi.get(__ret__, 'module_id'), + read=pulumi.get(__ret__, 'read'), + stack_id=pulumi.get(__ret__, 'stack_id'), + write=pulumi.get(__ret__, 'write')) @_utilities.lift_output_func(get_aws_integration_attachment) diff --git a/sdk/python/pulumi_spacelift/get_aws_integration_attachment_external_id.py b/sdk/python/pulumi_spacelift/get_aws_integration_attachment_external_id.py index 3cef7c8..0b65395 100644 --- a/sdk/python/pulumi_spacelift/get_aws_integration_attachment_external_id.py +++ b/sdk/python/pulumi_spacelift/get_aws_integration_attachment_external_id.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -170,14 +170,14 @@ def get_aws_integration_attachment_external_id(integration_id: Optional[str] = N __ret__ = pulumi.runtime.invoke('spacelift:index/getAwsIntegrationAttachmentExternalId:getAwsIntegrationAttachmentExternalId', __args__, opts=opts, typ=GetAwsIntegrationAttachmentExternalIdResult).value return AwaitableGetAwsIntegrationAttachmentExternalIdResult( - assume_role_policy_statement=__ret__.assume_role_policy_statement, - external_id=__ret__.external_id, - id=__ret__.id, - integration_id=__ret__.integration_id, - module_id=__ret__.module_id, - read=__ret__.read, - stack_id=__ret__.stack_id, - write=__ret__.write) + assume_role_policy_statement=pulumi.get(__ret__, 'assume_role_policy_statement'), + external_id=pulumi.get(__ret__, 'external_id'), + id=pulumi.get(__ret__, 'id'), + integration_id=pulumi.get(__ret__, 'integration_id'), + module_id=pulumi.get(__ret__, 'module_id'), + read=pulumi.get(__ret__, 'read'), + stack_id=pulumi.get(__ret__, 'stack_id'), + write=pulumi.get(__ret__, 'write')) @_utilities.lift_output_func(get_aws_integration_attachment_external_id) diff --git a/sdk/python/pulumi_spacelift/get_aws_integrations.py b/sdk/python/pulumi_spacelift/get_aws_integrations.py new file mode 100644 index 0000000..41193b9 --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_aws_integrations.py @@ -0,0 +1,75 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs + +__all__ = [ + 'GetAwsIntegrationsResult', + 'AwaitableGetAwsIntegrationsResult', + 'get_aws_integrations', + 'get_aws_integrations_output', +] + +@pulumi.output_type +class GetAwsIntegrationsResult: + """ + A collection of values returned by getAwsIntegrations. + """ + def __init__(__self__, id=None, integrations=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if integrations and not isinstance(integrations, list): + raise TypeError("Expected argument 'integrations' to be a list") + pulumi.set(__self__, "integrations", integrations) + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def integrations(self) -> Sequence['outputs.GetAwsIntegrationsIntegrationResult']: + return pulumi.get(self, "integrations") + + +class AwaitableGetAwsIntegrationsResult(GetAwsIntegrationsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetAwsIntegrationsResult( + id=self.id, + integrations=self.integrations) + + +def get_aws_integrations(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetAwsIntegrationsResult: + """ + `get_aws_integrations` represents a list of all the AWS integrations in the Spacelift account visible to the API user. + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getAwsIntegrations:getAwsIntegrations', __args__, opts=opts, typ=GetAwsIntegrationsResult).value + + return AwaitableGetAwsIntegrationsResult( + id=pulumi.get(__ret__, 'id'), + integrations=pulumi.get(__ret__, 'integrations')) + + +@_utilities.lift_output_func(get_aws_integrations) +def get_aws_integrations_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetAwsIntegrationsResult]: + """ + `get_aws_integrations` represents a list of all the AWS integrations in the Spacelift account visible to the API user. + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_aws_role.py b/sdk/python/pulumi_spacelift/get_aws_role.py index a441453..31f3a82 100644 --- a/sdk/python/pulumi_spacelift/get_aws_role.py +++ b/sdk/python/pulumi_spacelift/get_aws_role.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -147,13 +147,13 @@ def get_aws_role(module_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getAwsRole:getAwsRole', __args__, opts=opts, typ=GetAwsRoleResult).value return AwaitableGetAwsRoleResult( - duration_seconds=__ret__.duration_seconds, - external_id=__ret__.external_id, - generate_credentials_in_worker=__ret__.generate_credentials_in_worker, - id=__ret__.id, - module_id=__ret__.module_id, - role_arn=__ret__.role_arn, - stack_id=__ret__.stack_id) + duration_seconds=pulumi.get(__ret__, 'duration_seconds'), + external_id=pulumi.get(__ret__, 'external_id'), + generate_credentials_in_worker=pulumi.get(__ret__, 'generate_credentials_in_worker'), + id=pulumi.get(__ret__, 'id'), + module_id=pulumi.get(__ret__, 'module_id'), + role_arn=pulumi.get(__ret__, 'role_arn'), + stack_id=pulumi.get(__ret__, 'stack_id')) @_utilities.lift_output_func(get_aws_role) diff --git a/sdk/python/pulumi_spacelift/get_azure_devops_integration.py b/sdk/python/pulumi_spacelift/get_azure_devops_integration.py index bae45f6..f0d79b4 100644 --- a/sdk/python/pulumi_spacelift/get_azure_devops_integration.py +++ b/sdk/python/pulumi_spacelift/get_azure_devops_integration.py @@ -6,13 +6,14 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ 'GetAzureDevopsIntegrationResult', 'AwaitableGetAzureDevopsIntegrationResult', 'get_azure_devops_integration', + 'get_azure_devops_integration_output', ] @pulumi.output_type @@ -85,6 +86,23 @@ def get_azure_devops_integration(opts: Optional[pulumi.InvokeOptions] = None) -> __ret__ = pulumi.runtime.invoke('spacelift:index/getAzureDevopsIntegration:getAzureDevopsIntegration', __args__, opts=opts, typ=GetAzureDevopsIntegrationResult).value return AwaitableGetAzureDevopsIntegrationResult( - id=__ret__.id, - organization_url=__ret__.organization_url, - webhook_password=__ret__.webhook_password) + id=pulumi.get(__ret__, 'id'), + organization_url=pulumi.get(__ret__, 'organization_url'), + webhook_password=pulumi.get(__ret__, 'webhook_password')) + + +@_utilities.lift_output_func(get_azure_devops_integration) +def get_azure_devops_integration_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetAzureDevopsIntegrationResult]: + """ + `get_azure_devops_integration` returns details about Azure DevOps integration + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + azure_devops_integration = spacelift.get_azure_devops_integration() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_azure_integration.py b/sdk/python/pulumi_spacelift/get_azure_integration.py index ad87476..1d79ac0 100644 --- a/sdk/python/pulumi_spacelift/get_azure_integration.py +++ b/sdk/python/pulumi_spacelift/get_azure_integration.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -190,17 +190,17 @@ def get_azure_integration(integration_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getAzureIntegration:getAzureIntegration', __args__, opts=opts, typ=GetAzureIntegrationResult).value return AwaitableGetAzureIntegrationResult( - admin_consent_provided=__ret__.admin_consent_provided, - admin_consent_url=__ret__.admin_consent_url, - application_id=__ret__.application_id, - default_subscription_id=__ret__.default_subscription_id, - display_name=__ret__.display_name, - id=__ret__.id, - integration_id=__ret__.integration_id, - labels=__ret__.labels, - name=__ret__.name, - space_id=__ret__.space_id, - tenant_id=__ret__.tenant_id) + admin_consent_provided=pulumi.get(__ret__, 'admin_consent_provided'), + admin_consent_url=pulumi.get(__ret__, 'admin_consent_url'), + application_id=pulumi.get(__ret__, 'application_id'), + default_subscription_id=pulumi.get(__ret__, 'default_subscription_id'), + display_name=pulumi.get(__ret__, 'display_name'), + id=pulumi.get(__ret__, 'id'), + integration_id=pulumi.get(__ret__, 'integration_id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + space_id=pulumi.get(__ret__, 'space_id'), + tenant_id=pulumi.get(__ret__, 'tenant_id')) @_utilities.lift_output_func(get_azure_integration) diff --git a/sdk/python/pulumi_spacelift/get_azure_integration_attachment.py b/sdk/python/pulumi_spacelift/get_azure_integration_attachment.py index 03a293b..799670f 100644 --- a/sdk/python/pulumi_spacelift/get_azure_integration_attachment.py +++ b/sdk/python/pulumi_spacelift/get_azure_integration_attachment.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -158,14 +158,14 @@ def get_azure_integration_attachment(integration_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getAzureIntegrationAttachment:getAzureIntegrationAttachment', __args__, opts=opts, typ=GetAzureIntegrationAttachmentResult).value return AwaitableGetAzureIntegrationAttachmentResult( - attachment_id=__ret__.attachment_id, - id=__ret__.id, - integration_id=__ret__.integration_id, - module_id=__ret__.module_id, - read=__ret__.read, - stack_id=__ret__.stack_id, - subscription_id=__ret__.subscription_id, - write=__ret__.write) + attachment_id=pulumi.get(__ret__, 'attachment_id'), + id=pulumi.get(__ret__, 'id'), + integration_id=pulumi.get(__ret__, 'integration_id'), + module_id=pulumi.get(__ret__, 'module_id'), + read=pulumi.get(__ret__, 'read'), + stack_id=pulumi.get(__ret__, 'stack_id'), + subscription_id=pulumi.get(__ret__, 'subscription_id'), + write=pulumi.get(__ret__, 'write')) @_utilities.lift_output_func(get_azure_integration_attachment) diff --git a/sdk/python/pulumi_spacelift/get_azure_integrations.py b/sdk/python/pulumi_spacelift/get_azure_integrations.py new file mode 100644 index 0000000..868161f --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_azure_integrations.py @@ -0,0 +1,75 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs + +__all__ = [ + 'GetAzureIntegrationsResult', + 'AwaitableGetAzureIntegrationsResult', + 'get_azure_integrations', + 'get_azure_integrations_output', +] + +@pulumi.output_type +class GetAzureIntegrationsResult: + """ + A collection of values returned by getAzureIntegrations. + """ + def __init__(__self__, id=None, integrations=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if integrations and not isinstance(integrations, list): + raise TypeError("Expected argument 'integrations' to be a list") + pulumi.set(__self__, "integrations", integrations) + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def integrations(self) -> Sequence['outputs.GetAzureIntegrationsIntegrationResult']: + return pulumi.get(self, "integrations") + + +class AwaitableGetAzureIntegrationsResult(GetAzureIntegrationsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetAzureIntegrationsResult( + id=self.id, + integrations=self.integrations) + + +def get_azure_integrations(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetAzureIntegrationsResult: + """ + `get_azure_integrations` represents a list of all the Azure integrations in the Spacelift account visible to the API user. + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getAzureIntegrations:getAzureIntegrations', __args__, opts=opts, typ=GetAzureIntegrationsResult).value + + return AwaitableGetAzureIntegrationsResult( + id=pulumi.get(__ret__, 'id'), + integrations=pulumi.get(__ret__, 'integrations')) + + +@_utilities.lift_output_func(get_azure_integrations) +def get_azure_integrations_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetAzureIntegrationsResult]: + """ + `get_azure_integrations` represents a list of all the Azure integrations in the Spacelift account visible to the API user. + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_bitbucket_cloud_integration.py b/sdk/python/pulumi_spacelift/get_bitbucket_cloud_integration.py index 79a675f..82980c7 100644 --- a/sdk/python/pulumi_spacelift/get_bitbucket_cloud_integration.py +++ b/sdk/python/pulumi_spacelift/get_bitbucket_cloud_integration.py @@ -6,13 +6,14 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ 'GetBitbucketCloudIntegrationResult', 'AwaitableGetBitbucketCloudIntegrationResult', 'get_bitbucket_cloud_integration', + 'get_bitbucket_cloud_integration_output', ] @pulumi.output_type @@ -73,5 +74,22 @@ def get_bitbucket_cloud_integration(opts: Optional[pulumi.InvokeOptions] = None) __ret__ = pulumi.runtime.invoke('spacelift:index/getBitbucketCloudIntegration:getBitbucketCloudIntegration', __args__, opts=opts, typ=GetBitbucketCloudIntegrationResult).value return AwaitableGetBitbucketCloudIntegrationResult( - id=__ret__.id, - username=__ret__.username) + id=pulumi.get(__ret__, 'id'), + username=pulumi.get(__ret__, 'username')) + + +@_utilities.lift_output_func(get_bitbucket_cloud_integration) +def get_bitbucket_cloud_integration_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetBitbucketCloudIntegrationResult]: + """ + `get_bitbucket_cloud_integration` returns details about Bitbucket Cloud integration + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + bitbucket_cloud_integration = spacelift.get_bitbucket_cloud_integration() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_bitbucket_datacenter_integration.py b/sdk/python/pulumi_spacelift/get_bitbucket_datacenter_integration.py index 3e4042f..461e438 100644 --- a/sdk/python/pulumi_spacelift/get_bitbucket_datacenter_integration.py +++ b/sdk/python/pulumi_spacelift/get_bitbucket_datacenter_integration.py @@ -6,13 +6,14 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ 'GetBitbucketDatacenterIntegrationResult', 'AwaitableGetBitbucketDatacenterIntegrationResult', 'get_bitbucket_datacenter_integration', + 'get_bitbucket_datacenter_integration_output', ] @pulumi.output_type @@ -20,7 +21,7 @@ class GetBitbucketDatacenterIntegrationResult: """ A collection of values returned by getBitbucketDatacenterIntegration. """ - def __init__(__self__, api_host=None, id=None, user_facing_host=None, webhook_secret=None): + def __init__(__self__, api_host=None, id=None, user_facing_host=None, webhook_secret=None, webhook_url=None): if api_host and not isinstance(api_host, str): raise TypeError("Expected argument 'api_host' to be a str") pulumi.set(__self__, "api_host", api_host) @@ -33,6 +34,9 @@ def __init__(__self__, api_host=None, id=None, user_facing_host=None, webhook_se if webhook_secret and not isinstance(webhook_secret, str): raise TypeError("Expected argument 'webhook_secret' to be a str") pulumi.set(__self__, "webhook_secret", webhook_secret) + if webhook_url and not isinstance(webhook_url, str): + raise TypeError("Expected argument 'webhook_url' to be a str") + pulumi.set(__self__, "webhook_url", webhook_url) @property @pulumi.getter(name="apiHost") @@ -66,6 +70,14 @@ def webhook_secret(self) -> str: """ return pulumi.get(self, "webhook_secret") + @property + @pulumi.getter(name="webhookUrl") + def webhook_url(self) -> str: + """ + Bitbucket Datacenter integration webhook URL + """ + return pulumi.get(self, "webhook_url") + class AwaitableGetBitbucketDatacenterIntegrationResult(GetBitbucketDatacenterIntegrationResult): # pylint: disable=using-constant-test @@ -76,7 +88,8 @@ def __await__(self): api_host=self.api_host, id=self.id, user_facing_host=self.user_facing_host, - webhook_secret=self.webhook_secret) + webhook_secret=self.webhook_secret, + webhook_url=self.webhook_url) def get_bitbucket_datacenter_integration(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetBitbucketDatacenterIntegrationResult: @@ -97,7 +110,25 @@ def get_bitbucket_datacenter_integration(opts: Optional[pulumi.InvokeOptions] = __ret__ = pulumi.runtime.invoke('spacelift:index/getBitbucketDatacenterIntegration:getBitbucketDatacenterIntegration', __args__, opts=opts, typ=GetBitbucketDatacenterIntegrationResult).value return AwaitableGetBitbucketDatacenterIntegrationResult( - api_host=__ret__.api_host, - id=__ret__.id, - user_facing_host=__ret__.user_facing_host, - webhook_secret=__ret__.webhook_secret) + api_host=pulumi.get(__ret__, 'api_host'), + id=pulumi.get(__ret__, 'id'), + user_facing_host=pulumi.get(__ret__, 'user_facing_host'), + webhook_secret=pulumi.get(__ret__, 'webhook_secret'), + webhook_url=pulumi.get(__ret__, 'webhook_url')) + + +@_utilities.lift_output_func(get_bitbucket_datacenter_integration) +def get_bitbucket_datacenter_integration_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetBitbucketDatacenterIntegrationResult]: + """ + `get_bitbucket_datacenter_integration` returns details about Bitbucket Datacenter integration + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + bitbucket_datacenter_integration = spacelift.get_bitbucket_datacenter_integration() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_context.py b/sdk/python/pulumi_spacelift/get_context.py index b1c495e..ed68bde 100644 --- a/sdk/python/pulumi_spacelift/get_context.py +++ b/sdk/python/pulumi_spacelift/get_context.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -124,12 +124,12 @@ def get_context(context_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getContext:getContext', __args__, opts=opts, typ=GetContextResult).value return AwaitableGetContextResult( - context_id=__ret__.context_id, - description=__ret__.description, - id=__ret__.id, - labels=__ret__.labels, - name=__ret__.name, - space_id=__ret__.space_id) + context_id=pulumi.get(__ret__, 'context_id'), + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + space_id=pulumi.get(__ret__, 'space_id')) @_utilities.lift_output_func(get_context) diff --git a/sdk/python/pulumi_spacelift/get_context_attachment.py b/sdk/python/pulumi_spacelift/get_context_attachment.py index ba1390c..d907035 100644 --- a/sdk/python/pulumi_spacelift/get_context_attachment.py +++ b/sdk/python/pulumi_spacelift/get_context_attachment.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -124,11 +124,11 @@ def get_context_attachment(context_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getContextAttachment:getContextAttachment', __args__, opts=opts, typ=GetContextAttachmentResult).value return AwaitableGetContextAttachmentResult( - context_id=__ret__.context_id, - id=__ret__.id, - module_id=__ret__.module_id, - priority=__ret__.priority, - stack_id=__ret__.stack_id) + context_id=pulumi.get(__ret__, 'context_id'), + id=pulumi.get(__ret__, 'id'), + module_id=pulumi.get(__ret__, 'module_id'), + priority=pulumi.get(__ret__, 'priority'), + stack_id=pulumi.get(__ret__, 'stack_id')) @_utilities.lift_output_func(get_context_attachment) diff --git a/sdk/python/pulumi_spacelift/get_contexts.py b/sdk/python/pulumi_spacelift/get_contexts.py new file mode 100644 index 0000000..ccff7b2 --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_contexts.py @@ -0,0 +1,130 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = [ + 'GetContextsResult', + 'AwaitableGetContextsResult', + 'get_contexts', + 'get_contexts_output', +] + +@pulumi.output_type +class GetContextsResult: + """ + A collection of values returned by getContexts. + """ + def __init__(__self__, contexts=None, id=None, labels=None): + if contexts and not isinstance(contexts, list): + raise TypeError("Expected argument 'contexts' to be a list") + pulumi.set(__self__, "contexts", contexts) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def contexts(self) -> Sequence['outputs.GetContextsContextResult']: + return pulumi.get(self, "contexts") + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Optional[Sequence['outputs.GetContextsLabelResult']]: + """ + Require contexts to have one of the labels + """ + return pulumi.get(self, "labels") + + +class AwaitableGetContextsResult(GetContextsResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetContextsResult( + contexts=self.contexts, + id=self.id, + labels=self.labels) + + +def get_contexts(labels: Optional[Sequence[pulumi.InputType['GetContextsLabelArgs']]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetContextsResult: + """ + `get_contexts` represents all the contexts in the Spacelift account visible to the API user. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + contexts = spacelift.get_contexts(labels=[ + spacelift.GetContextsLabelArgs( + any_ofs=[ + "foo", + "bar", + ], + ), + spacelift.GetContextsLabelArgs( + any_ofs=["baz"], + ), + ]) + ``` + """ + __args__ = dict() + __args__['labels'] = labels + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getContexts:getContexts', __args__, opts=opts, typ=GetContextsResult).value + + return AwaitableGetContextsResult( + contexts=pulumi.get(__ret__, 'contexts'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels')) + + +@_utilities.lift_output_func(get_contexts) +def get_contexts_output(labels: Optional[pulumi.Input[Optional[Sequence[pulumi.InputType['GetContextsLabelArgs']]]]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetContextsResult]: + """ + `get_contexts` represents all the contexts in the Spacelift account visible to the API user. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + contexts = spacelift.get_contexts(labels=[ + spacelift.GetContextsLabelArgs( + any_ofs=[ + "foo", + "bar", + ], + ), + spacelift.GetContextsLabelArgs( + any_ofs=["baz"], + ), + ]) + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_current_space.py b/sdk/python/pulumi_spacelift/get_current_space.py new file mode 100644 index 0000000..ba611c8 --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_current_space.py @@ -0,0 +1,88 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'GetCurrentSpaceResult', + 'AwaitableGetCurrentSpaceResult', + 'get_current_space', + 'get_current_space_output', +] + +@pulumi.output_type +class GetCurrentSpaceResult: + """ + A collection of values returned by getCurrentSpace. + """ + def __init__(__self__, id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + +class AwaitableGetCurrentSpaceResult(GetCurrentSpaceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetCurrentSpaceResult( + id=self.id) + + +def get_current_space(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetCurrentSpaceResult: + """ + `get_current_space` is a data source that provides information about the space that an administrative stack is in if the run is executed within Spacelift by a stack or module. This makes it easier to create resources within the same space. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + this = spacelift.get_current_space() + prod_k8s_ie = spacelift.Context("prod-k8s-ie", + description="Configuration details for the compute cluster in 🇮🇪", + space_id=this.id) + ``` + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getCurrentSpace:getCurrentSpace', __args__, opts=opts, typ=GetCurrentSpaceResult).value + + return AwaitableGetCurrentSpaceResult( + id=pulumi.get(__ret__, 'id')) + + +@_utilities.lift_output_func(get_current_space) +def get_current_space_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetCurrentSpaceResult]: + """ + `get_current_space` is a data source that provides information about the space that an administrative stack is in if the run is executed within Spacelift by a stack or module. This makes it easier to create resources within the same space. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + this = spacelift.get_current_space() + prod_k8s_ie = spacelift.Context("prod-k8s-ie", + description="Configuration details for the compute cluster in 🇮🇪", + space_id=this.id) + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_current_stack.py b/sdk/python/pulumi_spacelift/get_current_stack.py index 2be85c1..d9de066 100644 --- a/sdk/python/pulumi_spacelift/get_current_stack.py +++ b/sdk/python/pulumi_spacelift/get_current_stack.py @@ -6,13 +6,14 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ 'GetCurrentStackResult', 'AwaitableGetCurrentStackResult', 'get_current_stack', + 'get_current_stack_output', ] @pulumi.output_type @@ -64,4 +65,24 @@ def get_current_stack(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableG __ret__ = pulumi.runtime.invoke('spacelift:index/getCurrentStack:getCurrentStack', __args__, opts=opts, typ=GetCurrentStackResult).value return AwaitableGetCurrentStackResult( - id=__ret__.id) + id=pulumi.get(__ret__, 'id')) + + +@_utilities.lift_output_func(get_current_stack) +def get_current_stack_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetCurrentStackResult]: + """ + `get_current_stack` is a data source that provides information about the current administrative stack if the run is executed within Spacelift by a stack or module. This allows clever tricks like attaching contexts or policies to the stack that manages them. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + this = spacelift.get_current_stack() + core_kubeconfig = spacelift.EnvironmentVariable("core-kubeconfig", + stack_id=this.id, + value="bacon") + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_drift_detection.py b/sdk/python/pulumi_spacelift/get_drift_detection.py index be6853f..b6d1d6f 100644 --- a/sdk/python/pulumi_spacelift/get_drift_detection.py +++ b/sdk/python/pulumi_spacelift/get_drift_detection.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -21,10 +21,13 @@ class GetDriftDetectionResult: """ A collection of values returned by getDriftDetection. """ - def __init__(__self__, id=None, reconcile=None, schedules=None, stack_id=None, timezone=None): + def __init__(__self__, id=None, ignore_state=None, reconcile=None, schedules=None, stack_id=None, timezone=None): if id and not isinstance(id, str): raise TypeError("Expected argument 'id' to be a str") pulumi.set(__self__, "id", id) + if ignore_state and not isinstance(ignore_state, bool): + raise TypeError("Expected argument 'ignore_state' to be a bool") + pulumi.set(__self__, "ignore_state", ignore_state) if reconcile and not isinstance(reconcile, bool): raise TypeError("Expected argument 'reconcile' to be a bool") pulumi.set(__self__, "reconcile", reconcile) @@ -46,6 +49,14 @@ def id(self) -> str: """ return pulumi.get(self, "id") + @property + @pulumi.getter(name="ignoreState") + def ignore_state(self) -> Optional[bool]: + """ + Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. + """ + return pulumi.get(self, "ignore_state") + @property @pulumi.getter def reconcile(self) -> bool: @@ -86,13 +97,15 @@ def __await__(self): yield self return GetDriftDetectionResult( id=self.id, + ignore_state=self.ignore_state, reconcile=self.reconcile, schedules=self.schedules, stack_id=self.stack_id, timezone=self.timezone) -def get_drift_detection(stack_id: Optional[str] = None, +def get_drift_detection(ignore_state: Optional[bool] = None, + stack_id: Optional[str] = None, opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDriftDetectionResult: """ `DriftDetection` represents a Drift Detection configuration for a Stack. It will trigger a proposed run on the given schedule, which you can listen for using run state webhooks. If reconcile is true, then a tracked run will be triggered when drift is detected. @@ -107,23 +120,27 @@ def get_drift_detection(stack_id: Optional[str] = None, ``` + :param bool ignore_state: Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. :param str stack_id: ID of the stack for which to set up drift detection """ __args__ = dict() + __args__['ignoreState'] = ignore_state __args__['stackId'] = stack_id opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) __ret__ = pulumi.runtime.invoke('spacelift:index/getDriftDetection:getDriftDetection', __args__, opts=opts, typ=GetDriftDetectionResult).value return AwaitableGetDriftDetectionResult( - id=__ret__.id, - reconcile=__ret__.reconcile, - schedules=__ret__.schedules, - stack_id=__ret__.stack_id, - timezone=__ret__.timezone) + id=pulumi.get(__ret__, 'id'), + ignore_state=pulumi.get(__ret__, 'ignore_state'), + reconcile=pulumi.get(__ret__, 'reconcile'), + schedules=pulumi.get(__ret__, 'schedules'), + stack_id=pulumi.get(__ret__, 'stack_id'), + timezone=pulumi.get(__ret__, 'timezone')) @_utilities.lift_output_func(get_drift_detection) -def get_drift_detection_output(stack_id: Optional[pulumi.Input[str]] = None, +def get_drift_detection_output(ignore_state: Optional[pulumi.Input[Optional[bool]]] = None, + stack_id: Optional[pulumi.Input[str]] = None, opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDriftDetectionResult]: """ `DriftDetection` represents a Drift Detection configuration for a Stack. It will trigger a proposed run on the given schedule, which you can listen for using run state webhooks. If reconcile is true, then a tracked run will be triggered when drift is detected. @@ -138,6 +155,7 @@ def get_drift_detection_output(stack_id: Optional[pulumi.Input[str]] = None, ``` + :param bool ignore_state: Controls whether drift detection should be performed on a stack in any final state instead of just 'Finished'. :param str stack_id: ID of the stack for which to set up drift detection """ ... diff --git a/sdk/python/pulumi_spacelift/get_environment_variable.py b/sdk/python/pulumi_spacelift/get_environment_variable.py index 3c85f9b..278b454 100644 --- a/sdk/python/pulumi_spacelift/get_environment_variable.py +++ b/sdk/python/pulumi_spacelift/get_environment_variable.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -165,14 +165,14 @@ def get_environment_variable(context_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getEnvironmentVariable:getEnvironmentVariable', __args__, opts=opts, typ=GetEnvironmentVariableResult).value return AwaitableGetEnvironmentVariableResult( - checksum=__ret__.checksum, - context_id=__ret__.context_id, - id=__ret__.id, - module_id=__ret__.module_id, - name=__ret__.name, - stack_id=__ret__.stack_id, - value=__ret__.value, - write_only=__ret__.write_only) + checksum=pulumi.get(__ret__, 'checksum'), + context_id=pulumi.get(__ret__, 'context_id'), + id=pulumi.get(__ret__, 'id'), + module_id=pulumi.get(__ret__, 'module_id'), + name=pulumi.get(__ret__, 'name'), + stack_id=pulumi.get(__ret__, 'stack_id'), + value=pulumi.get(__ret__, 'value'), + write_only=pulumi.get(__ret__, 'write_only')) @_utilities.lift_output_func(get_environment_variable) diff --git a/sdk/python/pulumi_spacelift/get_gcp_service_account.py b/sdk/python/pulumi_spacelift/get_gcp_service_account.py index 54f25c2..2585bb9 100644 --- a/sdk/python/pulumi_spacelift/get_gcp_service_account.py +++ b/sdk/python/pulumi_spacelift/get_gcp_service_account.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -117,11 +117,11 @@ def get_gcp_service_account(module_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getGcpServiceAccount:getGcpServiceAccount', __args__, opts=opts, typ=GetGcpServiceAccountResult).value return AwaitableGetGcpServiceAccountResult( - id=__ret__.id, - module_id=__ret__.module_id, - service_account_email=__ret__.service_account_email, - stack_id=__ret__.stack_id, - token_scopes=__ret__.token_scopes) + id=pulumi.get(__ret__, 'id'), + module_id=pulumi.get(__ret__, 'module_id'), + service_account_email=pulumi.get(__ret__, 'service_account_email'), + stack_id=pulumi.get(__ret__, 'stack_id'), + token_scopes=pulumi.get(__ret__, 'token_scopes')) @_utilities.lift_output_func(get_gcp_service_account) diff --git a/sdk/python/pulumi_spacelift/get_github_enterprise_integration.py b/sdk/python/pulumi_spacelift/get_github_enterprise_integration.py index 56514ef..6c1a629 100644 --- a/sdk/python/pulumi_spacelift/get_github_enterprise_integration.py +++ b/sdk/python/pulumi_spacelift/get_github_enterprise_integration.py @@ -6,13 +6,14 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ 'GetGithubEnterpriseIntegrationResult', 'AwaitableGetGithubEnterpriseIntegrationResult', 'get_github_enterprise_integration', + 'get_github_enterprise_integration_output', ] @pulumi.output_type @@ -97,7 +98,24 @@ def get_github_enterprise_integration(opts: Optional[pulumi.InvokeOptions] = Non __ret__ = pulumi.runtime.invoke('spacelift:index/getGithubEnterpriseIntegration:getGithubEnterpriseIntegration', __args__, opts=opts, typ=GetGithubEnterpriseIntegrationResult).value return AwaitableGetGithubEnterpriseIntegrationResult( - api_host=__ret__.api_host, - app_id=__ret__.app_id, - id=__ret__.id, - webhook_secret=__ret__.webhook_secret) + api_host=pulumi.get(__ret__, 'api_host'), + app_id=pulumi.get(__ret__, 'app_id'), + id=pulumi.get(__ret__, 'id'), + webhook_secret=pulumi.get(__ret__, 'webhook_secret')) + + +@_utilities.lift_output_func(get_github_enterprise_integration) +def get_github_enterprise_integration_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetGithubEnterpriseIntegrationResult]: + """ + `get_github_enterprise_integration` returns details about Github Enterprise integration + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + github_enterprise_integration = spacelift.get_github_enterprise_integration() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_gitlab_integration.py b/sdk/python/pulumi_spacelift/get_gitlab_integration.py index 30a83ca..e59b5bd 100644 --- a/sdk/python/pulumi_spacelift/get_gitlab_integration.py +++ b/sdk/python/pulumi_spacelift/get_gitlab_integration.py @@ -6,13 +6,14 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ 'GetGitlabIntegrationResult', 'AwaitableGetGitlabIntegrationResult', 'get_gitlab_integration', + 'get_gitlab_integration_output', ] @pulumi.output_type @@ -85,6 +86,23 @@ def get_gitlab_integration(opts: Optional[pulumi.InvokeOptions] = None) -> Await __ret__ = pulumi.runtime.invoke('spacelift:index/getGitlabIntegration:getGitlabIntegration', __args__, opts=opts, typ=GetGitlabIntegrationResult).value return AwaitableGetGitlabIntegrationResult( - api_host=__ret__.api_host, - id=__ret__.id, - webhook_secret=__ret__.webhook_secret) + api_host=pulumi.get(__ret__, 'api_host'), + id=pulumi.get(__ret__, 'id'), + webhook_secret=pulumi.get(__ret__, 'webhook_secret')) + + +@_utilities.lift_output_func(get_gitlab_integration) +def get_gitlab_integration_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetGitlabIntegrationResult]: + """ + `get_gitlab_integration` returns details about Gitlab integration + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + gitlab_integration = spacelift.get_gitlab_integration() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_gitlab_webhook_endpoint.py b/sdk/python/pulumi_spacelift/get_gitlab_webhook_endpoint.py new file mode 100644 index 0000000..b3af39b --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_gitlab_webhook_endpoint.py @@ -0,0 +1,95 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'GetGitlabWebhookEndpointResult', + 'AwaitableGetGitlabWebhookEndpointResult', + 'get_gitlab_webhook_endpoint', + 'get_gitlab_webhook_endpoint_output', +] + +@pulumi.output_type +class GetGitlabWebhookEndpointResult: + """ + A collection of values returned by getGitlabWebhookEndpoint. + """ + def __init__(__self__, id=None, webhook_endpoint=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if webhook_endpoint and not isinstance(webhook_endpoint, str): + raise TypeError("Expected argument 'webhook_endpoint' to be a str") + pulumi.set(__self__, "webhook_endpoint", webhook_endpoint) + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="webhookEndpoint") + def webhook_endpoint(self) -> str: + """ + Gitlab webhook endpoint address + """ + return pulumi.get(self, "webhook_endpoint") + + +class AwaitableGetGitlabWebhookEndpointResult(GetGitlabWebhookEndpointResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetGitlabWebhookEndpointResult( + id=self.id, + webhook_endpoint=self.webhook_endpoint) + + +def get_gitlab_webhook_endpoint(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGitlabWebhookEndpointResult: + """ + `get_gitlab_webhook_endpoint` returns details about Gitlab webhook endpoint + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + this = spacelift.get_gitlab_webhook_endpoint() + ``` + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getGitlabWebhookEndpoint:getGitlabWebhookEndpoint', __args__, opts=opts, typ=GetGitlabWebhookEndpointResult).value + + return AwaitableGetGitlabWebhookEndpointResult( + id=pulumi.get(__ret__, 'id'), + webhook_endpoint=pulumi.get(__ret__, 'webhook_endpoint')) + + +@_utilities.lift_output_func(get_gitlab_webhook_endpoint) +def get_gitlab_webhook_endpoint_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetGitlabWebhookEndpointResult]: + """ + `get_gitlab_webhook_endpoint` returns details about Gitlab webhook endpoint + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + this = spacelift.get_gitlab_webhook_endpoint() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_ips.py b/sdk/python/pulumi_spacelift/get_ips.py index bc21216..e435825 100644 --- a/sdk/python/pulumi_spacelift/get_ips.py +++ b/sdk/python/pulumi_spacelift/get_ips.py @@ -6,13 +6,14 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ 'GetIPsResult', 'AwaitableGetIPsResult', 'get_ips', + 'get_ips_output', ] @pulumi.output_type @@ -57,7 +58,7 @@ def __await__(self): def get_ips(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetIPsResult: """ - `get_i_ps` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". + `get_ips` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". **NOTE:** this does not include the IP addresses of the workers in Spacelift's public worker pool. If you need to ensure that requests made during runs originate from a known set of IP addresses, please consider setting up a [private worker pool](https://docs.spacelift.io/concepts/worker-pools). ## Example Usage @@ -73,5 +74,22 @@ def get_ips(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetIPsResul __ret__ = pulumi.runtime.invoke('spacelift:index/getIPs:getIPs', __args__, opts=opts, typ=GetIPsResult).value return AwaitableGetIPsResult( - id=__ret__.id, - ips=__ret__.ips) + id=pulumi.get(__ret__, 'id'), + ips=pulumi.get(__ret__, 'ips')) + + +@_utilities.lift_output_func(get_ips) +def get_ips_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetIPsResult]: + """ + `get_ips` returns the list of Spacelift's outgoing IP addresses, which you can use to whitelist connections coming from the Spacelift's "mothership". **NOTE:** this does not include the IP addresses of the workers in Spacelift's public worker pool. If you need to ensure that requests made during runs originate from a known set of IP addresses, please consider setting up a [private worker pool](https://docs.spacelift.io/concepts/worker-pools). + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + ips = spacelift.get_ips() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_module.py b/sdk/python/pulumi_spacelift/get_module.py index bdf4419..9454da4 100644 --- a/sdk/python/pulumi_spacelift/get_module.py +++ b/sdk/python/pulumi_spacelift/get_module.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities from . import outputs @@ -22,7 +22,7 @@ class GetModuleResult: """ A collection of values returned by getModule. """ - def __init__(__self__, administrative=None, aws_assume_role_policy_statement=None, azure_devops=None, bitbucket_clouds=None, bitbucket_datacenters=None, branch=None, description=None, github_enterprises=None, gitlabs=None, id=None, labels=None, module_id=None, name=None, project_root=None, protect_from_deletion=None, repository=None, shared_accounts=None, space_id=None, terraform_provider=None, worker_pool_id=None): + def __init__(__self__, administrative=None, aws_assume_role_policy_statement=None, azure_devops=None, bitbucket_clouds=None, bitbucket_datacenters=None, branch=None, description=None, enable_local_preview=None, github_enterprises=None, gitlabs=None, id=None, labels=None, module_id=None, name=None, project_root=None, protect_from_deletion=None, repository=None, shared_accounts=None, space_id=None, terraform_provider=None, worker_pool_id=None, workflow_tool=None): if administrative and not isinstance(administrative, bool): raise TypeError("Expected argument 'administrative' to be a bool") pulumi.set(__self__, "administrative", administrative) @@ -44,6 +44,9 @@ def __init__(__self__, administrative=None, aws_assume_role_policy_statement=Non if description and not isinstance(description, str): raise TypeError("Expected argument 'description' to be a str") pulumi.set(__self__, "description", description) + if enable_local_preview and not isinstance(enable_local_preview, bool): + raise TypeError("Expected argument 'enable_local_preview' to be a bool") + pulumi.set(__self__, "enable_local_preview", enable_local_preview) if github_enterprises and not isinstance(github_enterprises, list): raise TypeError("Expected argument 'github_enterprises' to be a list") pulumi.set(__self__, "github_enterprises", github_enterprises) @@ -83,6 +86,9 @@ def __init__(__self__, administrative=None, aws_assume_role_policy_statement=Non if worker_pool_id and not isinstance(worker_pool_id, str): raise TypeError("Expected argument 'worker_pool_id' to be a str") pulumi.set(__self__, "worker_pool_id", worker_pool_id) + if workflow_tool and not isinstance(workflow_tool, str): + raise TypeError("Expected argument 'workflow_tool' to be a str") + pulumi.set(__self__, "workflow_tool", workflow_tool) @property @pulumi.getter @@ -140,6 +146,14 @@ def description(self) -> str: """ return pulumi.get(self, "description") + @property + @pulumi.getter(name="enableLocalPreview") + def enable_local_preview(self) -> bool: + """ + Indicates whether local preview versions can be triggered on this Module. + """ + return pulumi.get(self, "enable_local_preview") + @property @pulumi.getter(name="githubEnterprises") def github_enterprises(self) -> Sequence['outputs.GetModuleGithubEnterpriseResult']: @@ -235,6 +249,14 @@ def worker_pool_id(self) -> str: """ return pulumi.get(self, "worker_pool_id") + @property + @pulumi.getter(name="workflowTool") + def workflow_tool(self) -> str: + """ + Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. + """ + return pulumi.get(self, "workflow_tool") + class AwaitableGetModuleResult(GetModuleResult): # pylint: disable=using-constant-test @@ -249,6 +271,7 @@ def __await__(self): bitbucket_datacenters=self.bitbucket_datacenters, branch=self.branch, description=self.description, + enable_local_preview=self.enable_local_preview, github_enterprises=self.github_enterprises, gitlabs=self.gitlabs, id=self.id, @@ -261,7 +284,8 @@ def __await__(self): shared_accounts=self.shared_accounts, space_id=self.space_id, terraform_provider=self.terraform_provider, - worker_pool_id=self.worker_pool_id) + worker_pool_id=self.worker_pool_id, + workflow_tool=self.workflow_tool) def get_module(module_id: Optional[str] = None, @@ -285,26 +309,28 @@ def get_module(module_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getModule:getModule', __args__, opts=opts, typ=GetModuleResult).value return AwaitableGetModuleResult( - administrative=__ret__.administrative, - aws_assume_role_policy_statement=__ret__.aws_assume_role_policy_statement, - azure_devops=__ret__.azure_devops, - bitbucket_clouds=__ret__.bitbucket_clouds, - bitbucket_datacenters=__ret__.bitbucket_datacenters, - branch=__ret__.branch, - description=__ret__.description, - github_enterprises=__ret__.github_enterprises, - gitlabs=__ret__.gitlabs, - id=__ret__.id, - labels=__ret__.labels, - module_id=__ret__.module_id, - name=__ret__.name, - project_root=__ret__.project_root, - protect_from_deletion=__ret__.protect_from_deletion, - repository=__ret__.repository, - shared_accounts=__ret__.shared_accounts, - space_id=__ret__.space_id, - terraform_provider=__ret__.terraform_provider, - worker_pool_id=__ret__.worker_pool_id) + administrative=pulumi.get(__ret__, 'administrative'), + aws_assume_role_policy_statement=pulumi.get(__ret__, 'aws_assume_role_policy_statement'), + azure_devops=pulumi.get(__ret__, 'azure_devops'), + bitbucket_clouds=pulumi.get(__ret__, 'bitbucket_clouds'), + bitbucket_datacenters=pulumi.get(__ret__, 'bitbucket_datacenters'), + branch=pulumi.get(__ret__, 'branch'), + description=pulumi.get(__ret__, 'description'), + enable_local_preview=pulumi.get(__ret__, 'enable_local_preview'), + github_enterprises=pulumi.get(__ret__, 'github_enterprises'), + gitlabs=pulumi.get(__ret__, 'gitlabs'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + module_id=pulumi.get(__ret__, 'module_id'), + name=pulumi.get(__ret__, 'name'), + project_root=pulumi.get(__ret__, 'project_root'), + protect_from_deletion=pulumi.get(__ret__, 'protect_from_deletion'), + repository=pulumi.get(__ret__, 'repository'), + shared_accounts=pulumi.get(__ret__, 'shared_accounts'), + space_id=pulumi.get(__ret__, 'space_id'), + terraform_provider=pulumi.get(__ret__, 'terraform_provider'), + worker_pool_id=pulumi.get(__ret__, 'worker_pool_id'), + workflow_tool=pulumi.get(__ret__, 'workflow_tool')) @_utilities.lift_output_func(get_module) diff --git a/sdk/python/pulumi_spacelift/get_mountedfile.py b/sdk/python/pulumi_spacelift/get_mountedfile.py index 2c04345..4f600fc 100644 --- a/sdk/python/pulumi_spacelift/get_mountedfile.py +++ b/sdk/python/pulumi_spacelift/get_mountedfile.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -165,14 +165,14 @@ def get_mountedfile(context_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getMountedfile:getMountedfile', __args__, opts=opts, typ=GetMountedfileResult).value return AwaitableGetMountedfileResult( - checksum=__ret__.checksum, - content=__ret__.content, - context_id=__ret__.context_id, - id=__ret__.id, - module_id=__ret__.module_id, - relative_path=__ret__.relative_path, - stack_id=__ret__.stack_id, - write_only=__ret__.write_only) + checksum=pulumi.get(__ret__, 'checksum'), + content=pulumi.get(__ret__, 'content'), + context_id=pulumi.get(__ret__, 'context_id'), + id=pulumi.get(__ret__, 'id'), + module_id=pulumi.get(__ret__, 'module_id'), + relative_path=pulumi.get(__ret__, 'relative_path'), + stack_id=pulumi.get(__ret__, 'stack_id'), + write_only=pulumi.get(__ret__, 'write_only')) @_utilities.lift_output_func(get_mountedfile) diff --git a/sdk/python/pulumi_spacelift/get_named_webhook.py b/sdk/python/pulumi_spacelift/get_named_webhook.py new file mode 100644 index 0000000..a1820bd --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_named_webhook.py @@ -0,0 +1,177 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'GetNamedWebhookResult', + 'AwaitableGetNamedWebhookResult', + 'get_named_webhook', + 'get_named_webhook_output', +] + +@pulumi.output_type +class GetNamedWebhookResult: + """ + A collection of values returned by getNamedWebhook. + """ + def __init__(__self__, enabled=None, endpoint=None, id=None, labels=None, name=None, secret=None, secret_header_keys=None, space_id=None, webhook_id=None): + if enabled and not isinstance(enabled, bool): + raise TypeError("Expected argument 'enabled' to be a bool") + pulumi.set(__self__, "enabled", enabled) + if endpoint and not isinstance(endpoint, str): + raise TypeError("Expected argument 'endpoint' to be a str") + pulumi.set(__self__, "endpoint", endpoint) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if secret and not isinstance(secret, str): + raise TypeError("Expected argument 'secret' to be a str") + pulumi.set(__self__, "secret", secret) + if secret_header_keys and not isinstance(secret_header_keys, list): + raise TypeError("Expected argument 'secret_header_keys' to be a list") + pulumi.set(__self__, "secret_header_keys", secret_header_keys) + if space_id and not isinstance(space_id, str): + raise TypeError("Expected argument 'space_id' to be a str") + pulumi.set(__self__, "space_id", space_id) + if webhook_id and not isinstance(webhook_id, str): + raise TypeError("Expected argument 'webhook_id' to be a str") + pulumi.set(__self__, "webhook_id", webhook_id) + + @property + @pulumi.getter + def enabled(self) -> bool: + """ + enables or disables sending webhooks. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter + def endpoint(self) -> str: + """ + endpoint to send the requests to + """ + return pulumi.get(self, "endpoint") + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Sequence[str]: + """ + labels for the webhook to use when referring in policies or filtering them + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> str: + """ + the name for the webhook which will also be used to generate the id + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def secret(self) -> str: + """ + secret used to sign each request so you're able to verify that the request comes from us. + """ + return pulumi.get(self, "secret") + + @property + @pulumi.getter(name="secretHeaderKeys") + def secret_header_keys(self) -> Sequence[str]: + """ + secret header keys which are currently set for this webhook + """ + return pulumi.get(self, "secret_header_keys") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> str: + """ + ID of the space the webhook is in + """ + return pulumi.get(self, "space_id") + + @property + @pulumi.getter(name="webhookId") + def webhook_id(self) -> str: + """ + ID of the webhook + """ + return pulumi.get(self, "webhook_id") + + +class AwaitableGetNamedWebhookResult(GetNamedWebhookResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetNamedWebhookResult( + enabled=self.enabled, + endpoint=self.endpoint, + id=self.id, + labels=self.labels, + name=self.name, + secret=self.secret, + secret_header_keys=self.secret_header_keys, + space_id=self.space_id, + webhook_id=self.webhook_id) + + +def get_named_webhook(webhook_id: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNamedWebhookResult: + """ + `NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + + + :param str webhook_id: ID of the webhook + """ + __args__ = dict() + __args__['webhookId'] = webhook_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getNamedWebhook:getNamedWebhook', __args__, opts=opts, typ=GetNamedWebhookResult).value + + return AwaitableGetNamedWebhookResult( + enabled=pulumi.get(__ret__, 'enabled'), + endpoint=pulumi.get(__ret__, 'endpoint'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + secret=pulumi.get(__ret__, 'secret'), + secret_header_keys=pulumi.get(__ret__, 'secret_header_keys'), + space_id=pulumi.get(__ret__, 'space_id'), + webhook_id=pulumi.get(__ret__, 'webhook_id')) + + +@_utilities.lift_output_func(get_named_webhook) +def get_named_webhook_output(webhook_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetNamedWebhookResult]: + """ + `NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + + + :param str webhook_id: ID of the webhook + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_policies.py b/sdk/python/pulumi_spacelift/get_policies.py index 53d71d1..1b1cb8b 100644 --- a/sdk/python/pulumi_spacelift/get_policies.py +++ b/sdk/python/pulumi_spacelift/get_policies.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities from . import outputs @@ -95,10 +95,6 @@ def get_policies(labels: Optional[Sequence[str]] = None, labels=["autoattach"]) pulumi.export("policyIds", [__item["id"] for __item in data["spacelift_policies"]["this"]["policies"]]) ``` - - - :param Sequence[str] labels: required labels to match - :param str type: required policy type """ __args__ = dict() __args__['labels'] = labels @@ -107,10 +103,10 @@ def get_policies(labels: Optional[Sequence[str]] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getPolicies:getPolicies', __args__, opts=opts, typ=GetPoliciesResult).value return AwaitableGetPoliciesResult( - id=__ret__.id, - labels=__ret__.labels, - policies=__ret__.policies, - type=__ret__.type) + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + policies=pulumi.get(__ret__, 'policies'), + type=pulumi.get(__ret__, 'type')) @_utilities.lift_output_func(get_policies) @@ -131,9 +127,5 @@ def get_policies_output(labels: Optional[pulumi.Input[Optional[Sequence[str]]]] labels=["autoattach"]) pulumi.export("policyIds", [__item["id"] for __item in data["spacelift_policies"]["this"]["policies"]]) ``` - - - :param Sequence[str] labels: required labels to match - :param str type: required policy type """ ... diff --git a/sdk/python/pulumi_spacelift/get_policy.py b/sdk/python/pulumi_spacelift/get_policy.py index 48b2189..b5ed049 100644 --- a/sdk/python/pulumi_spacelift/get_policy.py +++ b/sdk/python/pulumi_spacelift/get_policy.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -137,13 +137,13 @@ def get_policy(policy_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getPolicy:getPolicy', __args__, opts=opts, typ=GetPolicyResult).value return AwaitableGetPolicyResult( - body=__ret__.body, - id=__ret__.id, - labels=__ret__.labels, - name=__ret__.name, - policy_id=__ret__.policy_id, - space_id=__ret__.space_id, - type=__ret__.type) + body=pulumi.get(__ret__, 'body'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + policy_id=pulumi.get(__ret__, 'policy_id'), + space_id=pulumi.get(__ret__, 'space_id'), + type=pulumi.get(__ret__, 'type')) @_utilities.lift_output_func(get_policy) diff --git a/sdk/python/pulumi_spacelift/get_scheduled_delete_stack.py b/sdk/python/pulumi_spacelift/get_scheduled_delete_stack.py new file mode 100644 index 0000000..1432dda --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_scheduled_delete_stack.py @@ -0,0 +1,156 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'GetScheduledDeleteStackResult', + 'AwaitableGetScheduledDeleteStackResult', + 'get_scheduled_delete_stack', + 'get_scheduled_delete_stack_output', +] + +@pulumi.output_type +class GetScheduledDeleteStackResult: + """ + A collection of values returned by getScheduledDeleteStack. + """ + def __init__(__self__, at=None, delete_resources=None, id=None, schedule_id=None, scheduled_delete_stack_id=None, stack_id=None): + if at and not isinstance(at, int): + raise TypeError("Expected argument 'at' to be a int") + pulumi.set(__self__, "at", at) + if delete_resources and not isinstance(delete_resources, bool): + raise TypeError("Expected argument 'delete_resources' to be a bool") + pulumi.set(__self__, "delete_resources", delete_resources) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if schedule_id and not isinstance(schedule_id, str): + raise TypeError("Expected argument 'schedule_id' to be a str") + pulumi.set(__self__, "schedule_id", schedule_id) + if scheduled_delete_stack_id and not isinstance(scheduled_delete_stack_id, str): + raise TypeError("Expected argument 'scheduled_delete_stack_id' to be a str") + pulumi.set(__self__, "scheduled_delete_stack_id", scheduled_delete_stack_id) + if stack_id and not isinstance(stack_id, str): + raise TypeError("Expected argument 'stack_id' to be a str") + pulumi.set(__self__, "stack_id", stack_id) + + @property + @pulumi.getter + def at(self) -> int: + """ + Timestamp (unix timestamp) at which time the scheduling should happen. + """ + return pulumi.get(self, "at") + + @property + @pulumi.getter(name="deleteResources") + def delete_resources(self) -> bool: + """ + Indicates whether the resources of the stack should be deleted. + """ + return pulumi.get(self, "delete_resources") + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="scheduleId") + def schedule_id(self) -> str: + """ + ID of the schedule + """ + return pulumi.get(self, "schedule_id") + + @property + @pulumi.getter(name="scheduledDeleteStackId") + def scheduled_delete_stack_id(self) -> str: + """ + ID of the scheduled delete*stack (stack*id/schedule_id) + """ + return pulumi.get(self, "scheduled_delete_stack_id") + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> str: + """ + Stack ID of the scheduling config + """ + return pulumi.get(self, "stack_id") + + +class AwaitableGetScheduledDeleteStackResult(GetScheduledDeleteStackResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetScheduledDeleteStackResult( + at=self.at, + delete_resources=self.delete_resources, + id=self.id, + schedule_id=self.schedule_id, + scheduled_delete_stack_id=self.scheduled_delete_stack_id, + stack_id=self.stack_id) + + +def get_scheduled_delete_stack(scheduled_delete_stack_id: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetScheduledDeleteStackResult: + """ + `ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + ireland_kubeconfig_delete = spacelift.get_scheduled_delete_stack(scheduled_delete_stack_id="$STACK_ID/$SCHEDULED_DELETE_STACK_ID") + ``` + + + :param str scheduled_delete_stack_id: ID of the scheduled delete*stack (stack*id/schedule_id) + """ + __args__ = dict() + __args__['scheduledDeleteStackId'] = scheduled_delete_stack_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getScheduledDeleteStack:getScheduledDeleteStack', __args__, opts=opts, typ=GetScheduledDeleteStackResult).value + + return AwaitableGetScheduledDeleteStackResult( + at=pulumi.get(__ret__, 'at'), + delete_resources=pulumi.get(__ret__, 'delete_resources'), + id=pulumi.get(__ret__, 'id'), + schedule_id=pulumi.get(__ret__, 'schedule_id'), + scheduled_delete_stack_id=pulumi.get(__ret__, 'scheduled_delete_stack_id'), + stack_id=pulumi.get(__ret__, 'stack_id')) + + +@_utilities.lift_output_func(get_scheduled_delete_stack) +def get_scheduled_delete_stack_output(scheduled_delete_stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetScheduledDeleteStackResult]: + """ + `ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + ireland_kubeconfig_delete = spacelift.get_scheduled_delete_stack(scheduled_delete_stack_id="$STACK_ID/$SCHEDULED_DELETE_STACK_ID") + ``` + + + :param str scheduled_delete_stack_id: ID of the scheduled delete*stack (stack*id/schedule_id) + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_scheduled_task.py b/sdk/python/pulumi_spacelift/get_scheduled_task.py new file mode 100644 index 0000000..d817485 --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_scheduled_task.py @@ -0,0 +1,182 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'GetScheduledTaskResult', + 'AwaitableGetScheduledTaskResult', + 'get_scheduled_task', + 'get_scheduled_task_output', +] + +@pulumi.output_type +class GetScheduledTaskResult: + """ + A collection of values returned by getScheduledTask. + """ + def __init__(__self__, at=None, command=None, everies=None, id=None, schedule_id=None, scheduled_task_id=None, stack_id=None, timezone=None): + if at and not isinstance(at, int): + raise TypeError("Expected argument 'at' to be a int") + pulumi.set(__self__, "at", at) + if command and not isinstance(command, str): + raise TypeError("Expected argument 'command' to be a str") + pulumi.set(__self__, "command", command) + if everies and not isinstance(everies, list): + raise TypeError("Expected argument 'everies' to be a list") + pulumi.set(__self__, "everies", everies) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if schedule_id and not isinstance(schedule_id, str): + raise TypeError("Expected argument 'schedule_id' to be a str") + pulumi.set(__self__, "schedule_id", schedule_id) + if scheduled_task_id and not isinstance(scheduled_task_id, str): + raise TypeError("Expected argument 'scheduled_task_id' to be a str") + pulumi.set(__self__, "scheduled_task_id", scheduled_task_id) + if stack_id and not isinstance(stack_id, str): + raise TypeError("Expected argument 'stack_id' to be a str") + pulumi.set(__self__, "stack_id", stack_id) + if timezone and not isinstance(timezone, str): + raise TypeError("Expected argument 'timezone' to be a str") + pulumi.set(__self__, "timezone", timezone) + + @property + @pulumi.getter + def at(self) -> int: + """ + Timestamp (unix timestamp) at which time the scheduling should happen. + """ + return pulumi.get(self, "at") + + @property + @pulumi.getter + def command(self) -> str: + """ + Command that will be run. + """ + return pulumi.get(self, "command") + + @property + @pulumi.getter + def everies(self) -> Sequence[str]: + """ + List of cron schedule expressions based on which the scheduled task should be triggered. + """ + return pulumi.get(self, "everies") + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="scheduleId") + def schedule_id(self) -> str: + """ + ID of the schedule + """ + return pulumi.get(self, "schedule_id") + + @property + @pulumi.getter(name="scheduledTaskId") + def scheduled_task_id(self) -> str: + """ + ID of the scheduled task (stack*id/schedule*id) + """ + return pulumi.get(self, "scheduled_task_id") + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> str: + """ + Stack ID of the scheduled task + """ + return pulumi.get(self, "stack_id") + + @property + @pulumi.getter + def timezone(self) -> str: + """ + Timezone in which the schedule is expressed. Defaults to `UTC`. + """ + return pulumi.get(self, "timezone") + + +class AwaitableGetScheduledTaskResult(GetScheduledTaskResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetScheduledTaskResult( + at=self.at, + command=self.command, + everies=self.everies, + id=self.id, + schedule_id=self.schedule_id, + scheduled_task_id=self.scheduled_task_id, + stack_id=self.stack_id, + timezone=self.timezone) + + +def get_scheduled_task(scheduled_task_id: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetScheduledTaskResult: + """ + `ScheduledTask` represents a scheduling configuration for a Stack. It will trigger a task on the given timestamp/schedule. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + ireland_kubeconfig_destroy = spacelift.get_scheduled_task(scheduled_task_id="$STACK_ID/$SCHEDULED_TASK_ID") + ``` + + + :param str scheduled_task_id: ID of the scheduled task (stack*id/schedule*id) + """ + __args__ = dict() + __args__['scheduledTaskId'] = scheduled_task_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getScheduledTask:getScheduledTask', __args__, opts=opts, typ=GetScheduledTaskResult).value + + return AwaitableGetScheduledTaskResult( + at=pulumi.get(__ret__, 'at'), + command=pulumi.get(__ret__, 'command'), + everies=pulumi.get(__ret__, 'everies'), + id=pulumi.get(__ret__, 'id'), + schedule_id=pulumi.get(__ret__, 'schedule_id'), + scheduled_task_id=pulumi.get(__ret__, 'scheduled_task_id'), + stack_id=pulumi.get(__ret__, 'stack_id'), + timezone=pulumi.get(__ret__, 'timezone')) + + +@_utilities.lift_output_func(get_scheduled_task) +def get_scheduled_task_output(scheduled_task_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetScheduledTaskResult]: + """ + `ScheduledTask` represents a scheduling configuration for a Stack. It will trigger a task on the given timestamp/schedule. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + ireland_kubeconfig_destroy = spacelift.get_scheduled_task(scheduled_task_id="$STACK_ID/$SCHEDULED_TASK_ID") + ``` + + + :param str scheduled_task_id: ID of the scheduled task (stack*id/schedule*id) + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_space.py b/sdk/python/pulumi_spacelift/get_space.py index d7944a5..e184746 100644 --- a/sdk/python/pulumi_spacelift/get_space.py +++ b/sdk/python/pulumi_spacelift/get_space.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -21,7 +21,7 @@ class GetSpaceResult: """ A collection of values returned by getSpace. """ - def __init__(__self__, description=None, id=None, inherit_entities=None, name=None, parent_space_id=None, space_id=None): + def __init__(__self__, description=None, id=None, inherit_entities=None, labels=None, name=None, parent_space_id=None, space_id=None): if description and not isinstance(description, str): raise TypeError("Expected argument 'description' to be a str") pulumi.set(__self__, "description", description) @@ -31,6 +31,9 @@ def __init__(__self__, description=None, id=None, inherit_entities=None, name=No if inherit_entities and not isinstance(inherit_entities, bool): raise TypeError("Expected argument 'inherit_entities' to be a bool") pulumi.set(__self__, "inherit_entities", inherit_entities) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) if name and not isinstance(name, str): raise TypeError("Expected argument 'name' to be a str") pulumi.set(__self__, "name", name) @@ -65,6 +68,14 @@ def inherit_entities(self) -> bool: """ return pulumi.get(self, "inherit_entities") + @property + @pulumi.getter + def labels(self) -> Sequence[str]: + """ + list of labels describing a space + """ + return pulumi.get(self, "labels") + @property @pulumi.getter def name(self) -> str: @@ -99,6 +110,7 @@ def __await__(self): description=self.description, id=self.id, inherit_entities=self.inherit_entities, + labels=self.labels, name=self.name, parent_space_id=self.parent_space_id, space_id=self.space_id) @@ -128,12 +140,13 @@ def get_space(space_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getSpace:getSpace', __args__, opts=opts, typ=GetSpaceResult).value return AwaitableGetSpaceResult( - description=__ret__.description, - id=__ret__.id, - inherit_entities=__ret__.inherit_entities, - name=__ret__.name, - parent_space_id=__ret__.parent_space_id, - space_id=__ret__.space_id) + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + inherit_entities=pulumi.get(__ret__, 'inherit_entities'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + parent_space_id=pulumi.get(__ret__, 'parent_space_id'), + space_id=pulumi.get(__ret__, 'space_id')) @_utilities.lift_output_func(get_space) diff --git a/sdk/python/pulumi_spacelift/get_space_by_path.py b/sdk/python/pulumi_spacelift/get_space_by_path.py new file mode 100644 index 0000000..8686884 --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_space_by_path.py @@ -0,0 +1,175 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'GetSpaceByPathResult', + 'AwaitableGetSpaceByPathResult', + 'get_space_by_path', + 'get_space_by_path_output', +] + +@pulumi.output_type +class GetSpaceByPathResult: + """ + A collection of values returned by getSpaceByPath. + """ + def __init__(__self__, description=None, id=None, inherit_entities=None, labels=None, name=None, parent_space_id=None, space_path=None): + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if inherit_entities and not isinstance(inherit_entities, bool): + raise TypeError("Expected argument 'inherit_entities' to be a bool") + pulumi.set(__self__, "inherit_entities", inherit_entities) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if parent_space_id and not isinstance(parent_space_id, str): + raise TypeError("Expected argument 'parent_space_id' to be a str") + pulumi.set(__self__, "parent_space_id", parent_space_id) + if space_path and not isinstance(space_path, str): + raise TypeError("Expected argument 'space_path' to be a str") + pulumi.set(__self__, "space_path", space_path) + + @property + @pulumi.getter + def description(self) -> str: + """ + free-form space description for users + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="inheritEntities") + def inherit_entities(self) -> bool: + """ + indication whether access to this space inherits read access to entities from the parent space + """ + return pulumi.get(self, "inherit_entities") + + @property + @pulumi.getter + def labels(self) -> Sequence[str]: + """ + list of labels describing a space + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> str: + """ + name of the space + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="parentSpaceId") + def parent_space_id(self) -> str: + """ + immutable ID (slug) of parent space + """ + return pulumi.get(self, "parent_space_id") + + @property + @pulumi.getter(name="spacePath") + def space_path(self) -> str: + """ + path to the space - a series of space names separated by `/` + """ + return pulumi.get(self, "space_path") + + +class AwaitableGetSpaceByPathResult(GetSpaceByPathResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSpaceByPathResult( + description=self.description, + id=self.id, + inherit_entities=self.inherit_entities, + labels=self.labels, + name=self.name, + parent_space_id=self.parent_space_id, + space_path=self.space_path) + + +def get_space_by_path(space_path: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSpaceByPathResult: + """ + `get_space_by_path` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. In contrary to `Space`, this resource is identified by a path, not by an ID. For this data source to work, path must be unique. If there are multiple spaces with the same path, this datasource will fail. + **Disclaimer:** + This datasource can only be used in a stack that resides in a space with inheritance enabled. In addition, the parent spaces (excluding root) must also have inheritance enabled. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + space = spacelift.get_space_by_path(space_path="root/second space/my space") + pulumi.export("spaceDescription", space.description) + ``` + + + :param str space_path: path to the space - a series of space names separated by `/` + """ + __args__ = dict() + __args__['spacePath'] = space_path + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getSpaceByPath:getSpaceByPath', __args__, opts=opts, typ=GetSpaceByPathResult).value + + return AwaitableGetSpaceByPathResult( + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + inherit_entities=pulumi.get(__ret__, 'inherit_entities'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + parent_space_id=pulumi.get(__ret__, 'parent_space_id'), + space_path=pulumi.get(__ret__, 'space_path')) + + +@_utilities.lift_output_func(get_space_by_path) +def get_space_by_path_output(space_path: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetSpaceByPathResult]: + """ + `get_space_by_path` represents a Spacelift **space** - a collection of resources such as stacks, modules, policies, etc. Allows for more granular access control. Can have a parent space. In contrary to `Space`, this resource is identified by a path, not by an ID. For this data source to work, path must be unique. If there are multiple spaces with the same path, this datasource will fail. + **Disclaimer:** + This datasource can only be used in a stack that resides in a space with inheritance enabled. In addition, the parent spaces (excluding root) must also have inheritance enabled. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + space = spacelift.get_space_by_path(space_path="root/second space/my space") + pulumi.export("spaceDescription", space.description) + ``` + + + :param str space_path: path to the space - a series of space names separated by `/` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_spaces.py b/sdk/python/pulumi_spacelift/get_spaces.py new file mode 100644 index 0000000..dffb09e --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_spaces.py @@ -0,0 +1,95 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs + +__all__ = [ + 'GetSpacesResult', + 'AwaitableGetSpacesResult', + 'get_spaces', + 'get_spaces_output', +] + +@pulumi.output_type +class GetSpacesResult: + """ + A collection of values returned by getSpaces. + """ + def __init__(__self__, id=None, spaces=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if spaces and not isinstance(spaces, list): + raise TypeError("Expected argument 'spaces' to be a list") + pulumi.set(__self__, "spaces", spaces) + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def spaces(self) -> Sequence['outputs.GetSpacesSpaceResult']: + return pulumi.get(self, "spaces") + + +class AwaitableGetSpacesResult(GetSpacesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSpacesResult( + id=self.id, + spaces=self.spaces) + + +def get_spaces(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSpacesResult: + """ + `get_spaces` can find all spaces in the spacelift organization. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + this = spacelift.get_spaces() + pulumi.export("spaces", this.spaces) + ``` + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getSpaces:getSpaces', __args__, opts=opts, typ=GetSpacesResult).value + + return AwaitableGetSpacesResult( + id=pulumi.get(__ret__, 'id'), + spaces=pulumi.get(__ret__, 'spaces')) + + +@_utilities.lift_output_func(get_spaces) +def get_spaces_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetSpacesResult]: + """ + `get_spaces` can find all spaces in the spacelift organization. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + this = spacelift.get_spaces() + pulumi.export("spaces", this.spaces) + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_stack.py b/sdk/python/pulumi_spacelift/get_stack.py index af078bf..19ecab1 100644 --- a/sdk/python/pulumi_spacelift/get_stack.py +++ b/sdk/python/pulumi_spacelift/get_stack.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities from . import outputs @@ -22,7 +22,7 @@ class GetStackResult: """ A collection of values returned by getStack. """ - def __init__(__self__, administrative=None, after_applies=None, after_destroys=None, after_inits=None, after_performs=None, after_plans=None, ansibles=None, autodeploy=None, autoretry=None, aws_assume_role_policy_statement=None, azure_devops=None, before_applies=None, before_destroys=None, before_inits=None, before_performs=None, before_plans=None, bitbucket_clouds=None, bitbucket_datacenters=None, branch=None, cloudformations=None, description=None, enable_local_preview=None, github_enterprises=None, gitlabs=None, id=None, kubernetes=None, labels=None, manage_state=None, name=None, project_root=None, protect_from_deletion=None, pulumis=None, repository=None, runner_image=None, showcases=None, space_id=None, stack_id=None, terraform_smart_sanitization=None, terraform_version=None, terraform_workspace=None, worker_pool_id=None): + def __init__(__self__, administrative=None, after_applies=None, after_destroys=None, after_inits=None, after_performs=None, after_plans=None, after_runs=None, ansibles=None, autodeploy=None, autoretry=None, aws_assume_role_policy_statement=None, azure_devops=None, before_applies=None, before_destroys=None, before_inits=None, before_performs=None, before_plans=None, bitbucket_clouds=None, bitbucket_datacenters=None, branch=None, cloudformations=None, description=None, enable_local_preview=None, github_enterprises=None, gitlabs=None, id=None, kubernetes=None, labels=None, manage_state=None, name=None, project_root=None, protect_from_deletion=None, pulumis=None, raw_gits=None, repository=None, runner_image=None, showcases=None, space_id=None, stack_id=None, terraform_external_state_access=None, terraform_smart_sanitization=None, terraform_version=None, terraform_workflow_tool=None, terraform_workspace=None, worker_pool_id=None): if administrative and not isinstance(administrative, bool): raise TypeError("Expected argument 'administrative' to be a bool") pulumi.set(__self__, "administrative", administrative) @@ -41,6 +41,9 @@ def __init__(__self__, administrative=None, after_applies=None, after_destroys=N if after_plans and not isinstance(after_plans, list): raise TypeError("Expected argument 'after_plans' to be a list") pulumi.set(__self__, "after_plans", after_plans) + if after_runs and not isinstance(after_runs, list): + raise TypeError("Expected argument 'after_runs' to be a list") + pulumi.set(__self__, "after_runs", after_runs) if ansibles and not isinstance(ansibles, list): raise TypeError("Expected argument 'ansibles' to be a list") pulumi.set(__self__, "ansibles", ansibles) @@ -119,6 +122,9 @@ def __init__(__self__, administrative=None, after_applies=None, after_destroys=N if pulumis and not isinstance(pulumis, list): raise TypeError("Expected argument 'pulumis' to be a list") pulumi.set(__self__, "pulumis", pulumis) + if raw_gits and not isinstance(raw_gits, list): + raise TypeError("Expected argument 'raw_gits' to be a list") + pulumi.set(__self__, "raw_gits", raw_gits) if repository and not isinstance(repository, str): raise TypeError("Expected argument 'repository' to be a str") pulumi.set(__self__, "repository", repository) @@ -134,12 +140,18 @@ def __init__(__self__, administrative=None, after_applies=None, after_destroys=N if stack_id and not isinstance(stack_id, str): raise TypeError("Expected argument 'stack_id' to be a str") pulumi.set(__self__, "stack_id", stack_id) + if terraform_external_state_access and not isinstance(terraform_external_state_access, bool): + raise TypeError("Expected argument 'terraform_external_state_access' to be a bool") + pulumi.set(__self__, "terraform_external_state_access", terraform_external_state_access) if terraform_smart_sanitization and not isinstance(terraform_smart_sanitization, bool): raise TypeError("Expected argument 'terraform_smart_sanitization' to be a bool") pulumi.set(__self__, "terraform_smart_sanitization", terraform_smart_sanitization) if terraform_version and not isinstance(terraform_version, str): raise TypeError("Expected argument 'terraform_version' to be a str") pulumi.set(__self__, "terraform_version", terraform_version) + if terraform_workflow_tool and not isinstance(terraform_workflow_tool, str): + raise TypeError("Expected argument 'terraform_workflow_tool' to be a str") + pulumi.set(__self__, "terraform_workflow_tool", terraform_workflow_tool) if terraform_workspace and not isinstance(terraform_workspace, str): raise TypeError("Expected argument 'terraform_workspace' to be a str") pulumi.set(__self__, "terraform_workspace", terraform_workspace) @@ -157,7 +169,7 @@ def administrative(self) -> bool: @property @pulumi.getter(name="afterApplies") - def after_applies(self) -> Optional[Sequence[str]]: + def after_applies(self) -> Sequence[str]: """ List of after-apply scripts """ @@ -165,7 +177,7 @@ def after_applies(self) -> Optional[Sequence[str]]: @property @pulumi.getter(name="afterDestroys") - def after_destroys(self) -> Optional[Sequence[str]]: + def after_destroys(self) -> Sequence[str]: """ List of after-destroy scripts """ @@ -173,7 +185,7 @@ def after_destroys(self) -> Optional[Sequence[str]]: @property @pulumi.getter(name="afterInits") - def after_inits(self) -> Optional[Sequence[str]]: + def after_inits(self) -> Sequence[str]: """ List of after-init scripts """ @@ -181,7 +193,7 @@ def after_inits(self) -> Optional[Sequence[str]]: @property @pulumi.getter(name="afterPerforms") - def after_performs(self) -> Optional[Sequence[str]]: + def after_performs(self) -> Sequence[str]: """ List of after-perform scripts """ @@ -189,12 +201,20 @@ def after_performs(self) -> Optional[Sequence[str]]: @property @pulumi.getter(name="afterPlans") - def after_plans(self) -> Optional[Sequence[str]]: + def after_plans(self) -> Sequence[str]: """ List of after-plan scripts """ return pulumi.get(self, "after_plans") + @property + @pulumi.getter(name="afterRuns") + def after_runs(self) -> Optional[Sequence[str]]: + """ + List of after-run scripts + """ + return pulumi.get(self, "after_runs") + @property @pulumi.getter def ansibles(self) -> Sequence['outputs.GetStackAnsibleResult']: @@ -237,7 +257,7 @@ def azure_devops(self) -> Sequence['outputs.GetStackAzureDevopResult']: @property @pulumi.getter(name="beforeApplies") - def before_applies(self) -> Optional[Sequence[str]]: + def before_applies(self) -> Sequence[str]: """ List of before-apply scripts """ @@ -245,7 +265,7 @@ def before_applies(self) -> Optional[Sequence[str]]: @property @pulumi.getter(name="beforeDestroys") - def before_destroys(self) -> Optional[Sequence[str]]: + def before_destroys(self) -> Sequence[str]: """ List of before-destroy scripts """ @@ -253,7 +273,7 @@ def before_destroys(self) -> Optional[Sequence[str]]: @property @pulumi.getter(name="beforeInits") - def before_inits(self) -> Optional[Sequence[str]]: + def before_inits(self) -> Sequence[str]: """ List of before-init scripts """ @@ -261,7 +281,7 @@ def before_inits(self) -> Optional[Sequence[str]]: @property @pulumi.getter(name="beforePerforms") - def before_performs(self) -> Optional[Sequence[str]]: + def before_performs(self) -> Sequence[str]: """ List of before-perform scripts """ @@ -269,7 +289,7 @@ def before_performs(self) -> Optional[Sequence[str]]: @property @pulumi.getter(name="beforePlans") - def before_plans(self) -> Optional[Sequence[str]]: + def before_plans(self) -> Sequence[str]: """ List of before-plan scripts """ @@ -400,6 +420,14 @@ def pulumis(self) -> Sequence['outputs.GetStackPulumiResult']: """ return pulumi.get(self, "pulumis") + @property + @pulumi.getter(name="rawGits") + def raw_gits(self) -> Sequence['outputs.GetStackRawGitResult']: + """ + One-way VCS integration using a raw Git repository link + """ + return pulumi.get(self, "raw_gits") + @property @pulumi.getter def repository(self) -> str: @@ -440,6 +468,14 @@ def stack_id(self) -> str: """ return pulumi.get(self, "stack_id") + @property + @pulumi.getter(name="terraformExternalStateAccess") + def terraform_external_state_access(self) -> bool: + """ + Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. + """ + return pulumi.get(self, "terraform_external_state_access") + @property @pulumi.getter(name="terraformSmartSanitization") def terraform_smart_sanitization(self) -> bool: @@ -450,6 +486,14 @@ def terraform_smart_sanitization(self) -> bool: def terraform_version(self) -> str: return pulumi.get(self, "terraform_version") + @property + @pulumi.getter(name="terraformWorkflowTool") + def terraform_workflow_tool(self) -> str: + """ + Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. + """ + return pulumi.get(self, "terraform_workflow_tool") + @property @pulumi.getter(name="terraformWorkspace") def terraform_workspace(self) -> str: @@ -476,6 +520,7 @@ def __await__(self): after_inits=self.after_inits, after_performs=self.after_performs, after_plans=self.after_plans, + after_runs=self.after_runs, ansibles=self.ansibles, autodeploy=self.autodeploy, autoretry=self.autoretry, @@ -502,13 +547,16 @@ def __await__(self): project_root=self.project_root, protect_from_deletion=self.protect_from_deletion, pulumis=self.pulumis, + raw_gits=self.raw_gits, repository=self.repository, runner_image=self.runner_image, showcases=self.showcases, space_id=self.space_id, stack_id=self.stack_id, + terraform_external_state_access=self.terraform_external_state_access, terraform_smart_sanitization=self.terraform_smart_sanitization, terraform_version=self.terraform_version, + terraform_workflow_tool=self.terraform_workflow_tool, terraform_workspace=self.terraform_workspace, worker_pool_id=self.worker_pool_id) @@ -518,6 +566,7 @@ def get_stack(after_applies: Optional[Sequence[str]] = None, after_inits: Optional[Sequence[str]] = None, after_performs: Optional[Sequence[str]] = None, after_plans: Optional[Sequence[str]] = None, + after_runs: Optional[Sequence[str]] = None, before_applies: Optional[Sequence[str]] = None, before_destroys: Optional[Sequence[str]] = None, before_inits: Optional[Sequence[str]] = None, @@ -543,6 +592,7 @@ def get_stack(after_applies: Optional[Sequence[str]] = None, :param Sequence[str] after_inits: List of after-init scripts :param Sequence[str] after_performs: List of after-perform scripts :param Sequence[str] after_plans: List of after-plan scripts + :param Sequence[str] after_runs: List of after-run scripts :param Sequence[str] before_applies: List of before-apply scripts :param Sequence[str] before_destroys: List of before-destroy scripts :param Sequence[str] before_inits: List of before-init scripts @@ -556,6 +606,7 @@ def get_stack(after_applies: Optional[Sequence[str]] = None, __args__['afterInits'] = after_inits __args__['afterPerforms'] = after_performs __args__['afterPlans'] = after_plans + __args__['afterRuns'] = after_runs __args__['beforeApplies'] = before_applies __args__['beforeDestroys'] = before_destroys __args__['beforeInits'] = before_inits @@ -566,47 +617,51 @@ def get_stack(after_applies: Optional[Sequence[str]] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getStack:getStack', __args__, opts=opts, typ=GetStackResult).value return AwaitableGetStackResult( - administrative=__ret__.administrative, - after_applies=__ret__.after_applies, - after_destroys=__ret__.after_destroys, - after_inits=__ret__.after_inits, - after_performs=__ret__.after_performs, - after_plans=__ret__.after_plans, - ansibles=__ret__.ansibles, - autodeploy=__ret__.autodeploy, - autoretry=__ret__.autoretry, - aws_assume_role_policy_statement=__ret__.aws_assume_role_policy_statement, - azure_devops=__ret__.azure_devops, - before_applies=__ret__.before_applies, - before_destroys=__ret__.before_destroys, - before_inits=__ret__.before_inits, - before_performs=__ret__.before_performs, - before_plans=__ret__.before_plans, - bitbucket_clouds=__ret__.bitbucket_clouds, - bitbucket_datacenters=__ret__.bitbucket_datacenters, - branch=__ret__.branch, - cloudformations=__ret__.cloudformations, - description=__ret__.description, - enable_local_preview=__ret__.enable_local_preview, - github_enterprises=__ret__.github_enterprises, - gitlabs=__ret__.gitlabs, - id=__ret__.id, - kubernetes=__ret__.kubernetes, - labels=__ret__.labels, - manage_state=__ret__.manage_state, - name=__ret__.name, - project_root=__ret__.project_root, - protect_from_deletion=__ret__.protect_from_deletion, - pulumis=__ret__.pulumis, - repository=__ret__.repository, - runner_image=__ret__.runner_image, - showcases=__ret__.showcases, - space_id=__ret__.space_id, - stack_id=__ret__.stack_id, - terraform_smart_sanitization=__ret__.terraform_smart_sanitization, - terraform_version=__ret__.terraform_version, - terraform_workspace=__ret__.terraform_workspace, - worker_pool_id=__ret__.worker_pool_id) + administrative=pulumi.get(__ret__, 'administrative'), + after_applies=pulumi.get(__ret__, 'after_applies'), + after_destroys=pulumi.get(__ret__, 'after_destroys'), + after_inits=pulumi.get(__ret__, 'after_inits'), + after_performs=pulumi.get(__ret__, 'after_performs'), + after_plans=pulumi.get(__ret__, 'after_plans'), + after_runs=pulumi.get(__ret__, 'after_runs'), + ansibles=pulumi.get(__ret__, 'ansibles'), + autodeploy=pulumi.get(__ret__, 'autodeploy'), + autoretry=pulumi.get(__ret__, 'autoretry'), + aws_assume_role_policy_statement=pulumi.get(__ret__, 'aws_assume_role_policy_statement'), + azure_devops=pulumi.get(__ret__, 'azure_devops'), + before_applies=pulumi.get(__ret__, 'before_applies'), + before_destroys=pulumi.get(__ret__, 'before_destroys'), + before_inits=pulumi.get(__ret__, 'before_inits'), + before_performs=pulumi.get(__ret__, 'before_performs'), + before_plans=pulumi.get(__ret__, 'before_plans'), + bitbucket_clouds=pulumi.get(__ret__, 'bitbucket_clouds'), + bitbucket_datacenters=pulumi.get(__ret__, 'bitbucket_datacenters'), + branch=pulumi.get(__ret__, 'branch'), + cloudformations=pulumi.get(__ret__, 'cloudformations'), + description=pulumi.get(__ret__, 'description'), + enable_local_preview=pulumi.get(__ret__, 'enable_local_preview'), + github_enterprises=pulumi.get(__ret__, 'github_enterprises'), + gitlabs=pulumi.get(__ret__, 'gitlabs'), + id=pulumi.get(__ret__, 'id'), + kubernetes=pulumi.get(__ret__, 'kubernetes'), + labels=pulumi.get(__ret__, 'labels'), + manage_state=pulumi.get(__ret__, 'manage_state'), + name=pulumi.get(__ret__, 'name'), + project_root=pulumi.get(__ret__, 'project_root'), + protect_from_deletion=pulumi.get(__ret__, 'protect_from_deletion'), + pulumis=pulumi.get(__ret__, 'pulumis'), + raw_gits=pulumi.get(__ret__, 'raw_gits'), + repository=pulumi.get(__ret__, 'repository'), + runner_image=pulumi.get(__ret__, 'runner_image'), + showcases=pulumi.get(__ret__, 'showcases'), + space_id=pulumi.get(__ret__, 'space_id'), + stack_id=pulumi.get(__ret__, 'stack_id'), + terraform_external_state_access=pulumi.get(__ret__, 'terraform_external_state_access'), + terraform_smart_sanitization=pulumi.get(__ret__, 'terraform_smart_sanitization'), + terraform_version=pulumi.get(__ret__, 'terraform_version'), + terraform_workflow_tool=pulumi.get(__ret__, 'terraform_workflow_tool'), + terraform_workspace=pulumi.get(__ret__, 'terraform_workspace'), + worker_pool_id=pulumi.get(__ret__, 'worker_pool_id')) @_utilities.lift_output_func(get_stack) @@ -615,6 +670,7 @@ def get_stack_output(after_applies: Optional[pulumi.Input[Optional[Sequence[str] after_inits: Optional[pulumi.Input[Optional[Sequence[str]]]] = None, after_performs: Optional[pulumi.Input[Optional[Sequence[str]]]] = None, after_plans: Optional[pulumi.Input[Optional[Sequence[str]]]] = None, + after_runs: Optional[pulumi.Input[Optional[Sequence[str]]]] = None, before_applies: Optional[pulumi.Input[Optional[Sequence[str]]]] = None, before_destroys: Optional[pulumi.Input[Optional[Sequence[str]]]] = None, before_inits: Optional[pulumi.Input[Optional[Sequence[str]]]] = None, @@ -640,6 +696,7 @@ def get_stack_output(after_applies: Optional[pulumi.Input[Optional[Sequence[str] :param Sequence[str] after_inits: List of after-init scripts :param Sequence[str] after_performs: List of after-perform scripts :param Sequence[str] after_plans: List of after-plan scripts + :param Sequence[str] after_runs: List of after-run scripts :param Sequence[str] before_applies: List of before-apply scripts :param Sequence[str] before_destroys: List of before-destroy scripts :param Sequence[str] before_inits: List of before-init scripts diff --git a/sdk/python/pulumi_spacelift/get_stack_aws_role.py b/sdk/python/pulumi_spacelift/get_stack_aws_role.py index 247972e..ecd438c 100644 --- a/sdk/python/pulumi_spacelift/get_stack_aws_role.py +++ b/sdk/python/pulumi_spacelift/get_stack_aws_role.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -149,13 +149,13 @@ def get_stack_aws_role(module_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getStackAwsRole:getStackAwsRole', __args__, opts=opts, typ=GetStackAwsRoleResult).value return AwaitableGetStackAwsRoleResult( - duration_seconds=__ret__.duration_seconds, - external_id=__ret__.external_id, - generate_credentials_in_worker=__ret__.generate_credentials_in_worker, - id=__ret__.id, - module_id=__ret__.module_id, - role_arn=__ret__.role_arn, - stack_id=__ret__.stack_id) + duration_seconds=pulumi.get(__ret__, 'duration_seconds'), + external_id=pulumi.get(__ret__, 'external_id'), + generate_credentials_in_worker=pulumi.get(__ret__, 'generate_credentials_in_worker'), + id=pulumi.get(__ret__, 'id'), + module_id=pulumi.get(__ret__, 'module_id'), + role_arn=pulumi.get(__ret__, 'role_arn'), + stack_id=pulumi.get(__ret__, 'stack_id')) @_utilities.lift_output_func(get_stack_aws_role) diff --git a/sdk/python/pulumi_spacelift/get_stack_gcp_service_account.py b/sdk/python/pulumi_spacelift/get_stack_gcp_service_account.py index a6411be..0051c2c 100644 --- a/sdk/python/pulumi_spacelift/get_stack_gcp_service_account.py +++ b/sdk/python/pulumi_spacelift/get_stack_gcp_service_account.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -117,11 +117,11 @@ def get_stack_gcp_service_account(module_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getStackGcpServiceAccount:getStackGcpServiceAccount', __args__, opts=opts, typ=GetStackGcpServiceAccountResult).value return AwaitableGetStackGcpServiceAccountResult( - id=__ret__.id, - module_id=__ret__.module_id, - service_account_email=__ret__.service_account_email, - stack_id=__ret__.stack_id, - token_scopes=__ret__.token_scopes) + id=pulumi.get(__ret__, 'id'), + module_id=pulumi.get(__ret__, 'module_id'), + service_account_email=pulumi.get(__ret__, 'service_account_email'), + stack_id=pulumi.get(__ret__, 'stack_id'), + token_scopes=pulumi.get(__ret__, 'token_scopes')) @_utilities.lift_output_func(get_stack_gcp_service_account) diff --git a/sdk/python/pulumi_spacelift/get_stacks.py b/sdk/python/pulumi_spacelift/get_stacks.py new file mode 100644 index 0000000..e660de9 --- /dev/null +++ b/sdk/python/pulumi_spacelift/get_stacks.py @@ -0,0 +1,269 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = [ + 'GetStacksResult', + 'AwaitableGetStacksResult', + 'get_stacks', + 'get_stacks_output', +] + +@pulumi.output_type +class GetStacksResult: + """ + A collection of values returned by getStacks. + """ + def __init__(__self__, administrative=None, branch=None, commit=None, id=None, labels=None, locked=None, name=None, project_root=None, repository=None, stacks=None, state=None, vendor=None, worker_pool=None): + if administrative and not isinstance(administrative, dict): + raise TypeError("Expected argument 'administrative' to be a dict") + pulumi.set(__self__, "administrative", administrative) + if branch and not isinstance(branch, dict): + raise TypeError("Expected argument 'branch' to be a dict") + pulumi.set(__self__, "branch", branch) + if commit and not isinstance(commit, dict): + raise TypeError("Expected argument 'commit' to be a dict") + pulumi.set(__self__, "commit", commit) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if labels and not isinstance(labels, list): + raise TypeError("Expected argument 'labels' to be a list") + pulumi.set(__self__, "labels", labels) + if locked and not isinstance(locked, dict): + raise TypeError("Expected argument 'locked' to be a dict") + pulumi.set(__self__, "locked", locked) + if name and not isinstance(name, dict): + raise TypeError("Expected argument 'name' to be a dict") + pulumi.set(__self__, "name", name) + if project_root and not isinstance(project_root, dict): + raise TypeError("Expected argument 'project_root' to be a dict") + pulumi.set(__self__, "project_root", project_root) + if repository and not isinstance(repository, dict): + raise TypeError("Expected argument 'repository' to be a dict") + pulumi.set(__self__, "repository", repository) + if stacks and not isinstance(stacks, list): + raise TypeError("Expected argument 'stacks' to be a list") + pulumi.set(__self__, "stacks", stacks) + if state and not isinstance(state, dict): + raise TypeError("Expected argument 'state' to be a dict") + pulumi.set(__self__, "state", state) + if vendor and not isinstance(vendor, dict): + raise TypeError("Expected argument 'vendor' to be a dict") + pulumi.set(__self__, "vendor", vendor) + if worker_pool and not isinstance(worker_pool, dict): + raise TypeError("Expected argument 'worker_pool' to be a dict") + pulumi.set(__self__, "worker_pool", worker_pool) + + @property + @pulumi.getter + def administrative(self) -> Optional['outputs.GetStacksAdministrativeResult']: + """ + Require stacks to be administrative or not + """ + return pulumi.get(self, "administrative") + + @property + @pulumi.getter + def branch(self) -> Optional['outputs.GetStacksBranchResult']: + """ + Require stacks to be on one of the branches + """ + return pulumi.get(self, "branch") + + @property + @pulumi.getter + def commit(self) -> Optional['outputs.GetStacksCommitResult']: + """ + Require stacks to be on one of the commits + """ + return pulumi.get(self, "commit") + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Optional[Sequence['outputs.GetStacksLabelResult']]: + """ + Require stacks to have one of the labels + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def locked(self) -> Optional['outputs.GetStacksLockedResult']: + """ + Require stacks to be locked + """ + return pulumi.get(self, "locked") + + @property + @pulumi.getter + def name(self) -> Optional['outputs.GetStacksNameResult']: + """ + Require stacks to have one of the names + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectRoot") + def project_root(self) -> Optional['outputs.GetStacksProjectRootResult']: + """ + Require stacks to be in one of the project roots + """ + return pulumi.get(self, "project_root") + + @property + @pulumi.getter + def repository(self) -> Optional['outputs.GetStacksRepositoryResult']: + """ + Require stacks to be in one of the repositories + """ + return pulumi.get(self, "repository") + + @property + @pulumi.getter + def stacks(self) -> Sequence['outputs.GetStacksStackResult']: + """ + List of stacks matching the predicates + """ + return pulumi.get(self, "stacks") + + @property + @pulumi.getter + def state(self) -> Optional['outputs.GetStacksStateResult']: + """ + Require stacks to have one of the states + """ + return pulumi.get(self, "state") + + @property + @pulumi.getter + def vendor(self) -> Optional['outputs.GetStacksVendorResult']: + """ + Require stacks to use one of the IaC vendors + """ + return pulumi.get(self, "vendor") + + @property + @pulumi.getter(name="workerPool") + def worker_pool(self) -> Optional['outputs.GetStacksWorkerPoolResult']: + """ + Require stacks to use one of the worker pools + """ + return pulumi.get(self, "worker_pool") + + +class AwaitableGetStacksResult(GetStacksResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetStacksResult( + administrative=self.administrative, + branch=self.branch, + commit=self.commit, + id=self.id, + labels=self.labels, + locked=self.locked, + name=self.name, + project_root=self.project_root, + repository=self.repository, + stacks=self.stacks, + state=self.state, + vendor=self.vendor, + worker_pool=self.worker_pool) + + +def get_stacks(administrative: Optional[pulumi.InputType['GetStacksAdministrativeArgs']] = None, + branch: Optional[pulumi.InputType['GetStacksBranchArgs']] = None, + commit: Optional[pulumi.InputType['GetStacksCommitArgs']] = None, + labels: Optional[Sequence[pulumi.InputType['GetStacksLabelArgs']]] = None, + locked: Optional[pulumi.InputType['GetStacksLockedArgs']] = None, + name: Optional[pulumi.InputType['GetStacksNameArgs']] = None, + project_root: Optional[pulumi.InputType['GetStacksProjectRootArgs']] = None, + repository: Optional[pulumi.InputType['GetStacksRepositoryArgs']] = None, + state: Optional[pulumi.InputType['GetStacksStateArgs']] = None, + vendor: Optional[pulumi.InputType['GetStacksVendorArgs']] = None, + worker_pool: Optional[pulumi.InputType['GetStacksWorkerPoolArgs']] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetStacksResult: + """ + `get_stacks` represents all the stacks in the Spacelift account visible to the API user, matching predicates. + + + :param pulumi.InputType['GetStacksCommitArgs'] commit: Require stacks to be on one of the commits + :param pulumi.InputType['GetStacksLockedArgs'] locked: Require stacks to be locked + :param pulumi.InputType['GetStacksStateArgs'] state: Require stacks to have one of the states + :param pulumi.InputType['GetStacksVendorArgs'] vendor: Require stacks to use one of the IaC vendors + :param pulumi.InputType['GetStacksWorkerPoolArgs'] worker_pool: Require stacks to use one of the worker pools + """ + __args__ = dict() + __args__['administrative'] = administrative + __args__['branch'] = branch + __args__['commit'] = commit + __args__['labels'] = labels + __args__['locked'] = locked + __args__['name'] = name + __args__['projectRoot'] = project_root + __args__['repository'] = repository + __args__['state'] = state + __args__['vendor'] = vendor + __args__['workerPool'] = worker_pool + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('spacelift:index/getStacks:getStacks', __args__, opts=opts, typ=GetStacksResult).value + + return AwaitableGetStacksResult( + administrative=pulumi.get(__ret__, 'administrative'), + branch=pulumi.get(__ret__, 'branch'), + commit=pulumi.get(__ret__, 'commit'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + locked=pulumi.get(__ret__, 'locked'), + name=pulumi.get(__ret__, 'name'), + project_root=pulumi.get(__ret__, 'project_root'), + repository=pulumi.get(__ret__, 'repository'), + stacks=pulumi.get(__ret__, 'stacks'), + state=pulumi.get(__ret__, 'state'), + vendor=pulumi.get(__ret__, 'vendor'), + worker_pool=pulumi.get(__ret__, 'worker_pool')) + + +@_utilities.lift_output_func(get_stacks) +def get_stacks_output(administrative: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksAdministrativeArgs']]]] = None, + branch: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksBranchArgs']]]] = None, + commit: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksCommitArgs']]]] = None, + labels: Optional[pulumi.Input[Optional[Sequence[pulumi.InputType['GetStacksLabelArgs']]]]] = None, + locked: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksLockedArgs']]]] = None, + name: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksNameArgs']]]] = None, + project_root: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksProjectRootArgs']]]] = None, + repository: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksRepositoryArgs']]]] = None, + state: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksStateArgs']]]] = None, + vendor: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksVendorArgs']]]] = None, + worker_pool: Optional[pulumi.Input[Optional[pulumi.InputType['GetStacksWorkerPoolArgs']]]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetStacksResult]: + """ + `get_stacks` represents all the stacks in the Spacelift account visible to the API user, matching predicates. + + + :param pulumi.InputType['GetStacksCommitArgs'] commit: Require stacks to be on one of the commits + :param pulumi.InputType['GetStacksLockedArgs'] locked: Require stacks to be locked + :param pulumi.InputType['GetStacksStateArgs'] state: Require stacks to have one of the states + :param pulumi.InputType['GetStacksVendorArgs'] vendor: Require stacks to use one of the IaC vendors + :param pulumi.InputType['GetStacksWorkerPoolArgs'] worker_pool: Require stacks to use one of the worker pools + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_vcs_agent_pool.py b/sdk/python/pulumi_spacelift/get_vcs_agent_pool.py index fe18aa5..e7c220e 100644 --- a/sdk/python/pulumi_spacelift/get_vcs_agent_pool.py +++ b/sdk/python/pulumi_spacelift/get_vcs_agent_pool.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -94,10 +94,10 @@ def get_vcs_agent_pool(vcs_agent_pool_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getVcsAgentPool:getVcsAgentPool', __args__, opts=opts, typ=GetVcsAgentPoolResult).value return AwaitableGetVcsAgentPoolResult( - description=__ret__.description, - id=__ret__.id, - name=__ret__.name, - vcs_agent_pool_id=__ret__.vcs_agent_pool_id) + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + vcs_agent_pool_id=pulumi.get(__ret__, 'vcs_agent_pool_id')) @_utilities.lift_output_func(get_vcs_agent_pool) diff --git a/sdk/python/pulumi_spacelift/get_vcs_agent_pools.py b/sdk/python/pulumi_spacelift/get_vcs_agent_pools.py index d298fcc..ddedae7 100644 --- a/sdk/python/pulumi_spacelift/get_vcs_agent_pools.py +++ b/sdk/python/pulumi_spacelift/get_vcs_agent_pools.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities from . import outputs @@ -14,6 +14,7 @@ 'GetVcsAgentPoolsResult', 'AwaitableGetVcsAgentPoolsResult', 'get_vcs_agent_pools', + 'get_vcs_agent_pools_output', ] @pulumi.output_type @@ -71,5 +72,22 @@ def get_vcs_agent_pools(opts: Optional[pulumi.InvokeOptions] = None) -> Awaitabl __ret__ = pulumi.runtime.invoke('spacelift:index/getVcsAgentPools:getVcsAgentPools', __args__, opts=opts, typ=GetVcsAgentPoolsResult).value return AwaitableGetVcsAgentPoolsResult( - id=__ret__.id, - vcs_agent_pools=__ret__.vcs_agent_pools) + id=pulumi.get(__ret__, 'id'), + vcs_agent_pools=pulumi.get(__ret__, 'vcs_agent_pools')) + + +@_utilities.lift_output_func(get_vcs_agent_pools) +def get_vcs_agent_pools_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetVcsAgentPoolsResult]: + """ + `get_vcs_agent_pools` represents the VCS agent pools assigned to the Spacelift account. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + vcs_agent_pools = spacelift.get_vcs_agent_pools() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/get_webhook.py b/sdk/python/pulumi_spacelift/get_webhook.py index 2dd0af6..73160d1 100644 --- a/sdk/python/pulumi_spacelift/get_webhook.py +++ b/sdk/python/pulumi_spacelift/get_webhook.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -145,13 +145,13 @@ def get_webhook(module_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getWebhook:getWebhook', __args__, opts=opts, typ=GetWebhookResult).value return AwaitableGetWebhookResult( - enabled=__ret__.enabled, - endpoint=__ret__.endpoint, - id=__ret__.id, - module_id=__ret__.module_id, - secret=__ret__.secret, - stack_id=__ret__.stack_id, - webhook_id=__ret__.webhook_id) + enabled=pulumi.get(__ret__, 'enabled'), + endpoint=pulumi.get(__ret__, 'endpoint'), + id=pulumi.get(__ret__, 'id'), + module_id=pulumi.get(__ret__, 'module_id'), + secret=pulumi.get(__ret__, 'secret'), + stack_id=pulumi.get(__ret__, 'stack_id'), + webhook_id=pulumi.get(__ret__, 'webhook_id')) @_utilities.lift_output_func(get_webhook) diff --git a/sdk/python/pulumi_spacelift/get_worker_pool.py b/sdk/python/pulumi_spacelift/get_worker_pool.py index e977503..f74bf1d 100644 --- a/sdk/python/pulumi_spacelift/get_worker_pool.py +++ b/sdk/python/pulumi_spacelift/get_worker_pool.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = [ @@ -124,7 +124,7 @@ def get_worker_pool(worker_pool_id: Optional[str] = None, import pulumi import pulumi_spacelift as spacelift - k8s_core = spacelift.get_worker_pool(worker_pool_id="k8s-core") + k8s_core = spacelift.get_worker_pool(worker_pool_id="01G1KTZ4BA86RBN3XNN3YK9EWT") ``` @@ -136,13 +136,13 @@ def get_worker_pool(worker_pool_id: Optional[str] = None, __ret__ = pulumi.runtime.invoke('spacelift:index/getWorkerPool:getWorkerPool', __args__, opts=opts, typ=GetWorkerPoolResult).value return AwaitableGetWorkerPoolResult( - config=__ret__.config, - description=__ret__.description, - id=__ret__.id, - labels=__ret__.labels, - name=__ret__.name, - space_id=__ret__.space_id, - worker_pool_id=__ret__.worker_pool_id) + config=pulumi.get(__ret__, 'config'), + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + space_id=pulumi.get(__ret__, 'space_id'), + worker_pool_id=pulumi.get(__ret__, 'worker_pool_id')) @_utilities.lift_output_func(get_worker_pool) @@ -157,7 +157,7 @@ def get_worker_pool_output(worker_pool_id: Optional[pulumi.Input[str]] = None, import pulumi import pulumi_spacelift as spacelift - k8s_core = spacelift.get_worker_pool(worker_pool_id="k8s-core") + k8s_core = spacelift.get_worker_pool(worker_pool_id="01G1KTZ4BA86RBN3XNN3YK9EWT") ``` diff --git a/sdk/python/pulumi_spacelift/get_worker_pools.py b/sdk/python/pulumi_spacelift/get_worker_pools.py index dd4ca78..521a720 100644 --- a/sdk/python/pulumi_spacelift/get_worker_pools.py +++ b/sdk/python/pulumi_spacelift/get_worker_pools.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities from . import outputs @@ -14,6 +14,7 @@ 'GetWorkerPoolsResult', 'AwaitableGetWorkerPoolsResult', 'get_worker_pools', + 'get_worker_pools_output', ] @pulumi.output_type @@ -71,5 +72,22 @@ def get_worker_pools(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGe __ret__ = pulumi.runtime.invoke('spacelift:index/getWorkerPools:getWorkerPools', __args__, opts=opts, typ=GetWorkerPoolsResult).value return AwaitableGetWorkerPoolsResult( - id=__ret__.id, - worker_pools=__ret__.worker_pools) + id=pulumi.get(__ret__, 'id'), + worker_pools=pulumi.get(__ret__, 'worker_pools')) + + +@_utilities.lift_output_func(get_worker_pools) +def get_worker_pools_output(opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetWorkerPoolsResult]: + """ + `get_worker_pools` represents the worker pools assigned to the Spacelift account. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + worker_pools = spacelift.get_worker_pools() + ``` + """ + ... diff --git a/sdk/python/pulumi_spacelift/idp_group_mapping.py b/sdk/python/pulumi_spacelift/idp_group_mapping.py new file mode 100644 index 0000000..56572d1 --- /dev/null +++ b/sdk/python/pulumi_spacelift/idp_group_mapping.py @@ -0,0 +1,250 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['IdpGroupMappingArgs', 'IdpGroupMapping'] + +@pulumi.input_type +class IdpGroupMappingArgs: + def __init__(__self__, *, + policies: pulumi.Input[Sequence[pulumi.Input['IdpGroupMappingPolicyArgs']]], + name: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a IdpGroupMapping resource. + :param pulumi.Input[str] name: Name of the user group - should be unique in one account + """ + IdpGroupMappingArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + policies=policies, + name=name, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + policies: Optional[pulumi.Input[Sequence[pulumi.Input['IdpGroupMappingPolicyArgs']]]] = None, + name: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if policies is None: + raise TypeError("Missing 'policies' argument") + + _setter("policies", policies) + if name is not None: + _setter("name", name) + + @property + @pulumi.getter + def policies(self) -> pulumi.Input[Sequence[pulumi.Input['IdpGroupMappingPolicyArgs']]]: + return pulumi.get(self, "policies") + + @policies.setter + def policies(self, value: pulumi.Input[Sequence[pulumi.Input['IdpGroupMappingPolicyArgs']]]): + pulumi.set(self, "policies", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + """ + Name of the user group - should be unique in one account + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _IdpGroupMappingState: + def __init__(__self__, *, + name: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input['IdpGroupMappingPolicyArgs']]]] = None): + """ + Input properties used for looking up and filtering IdpGroupMapping resources. + :param pulumi.Input[str] name: Name of the user group - should be unique in one account + """ + _IdpGroupMappingState._configure( + lambda key, value: pulumi.set(__self__, key, value), + name=name, + policies=policies, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + name: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input['IdpGroupMappingPolicyArgs']]]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + + if name is not None: + _setter("name", name) + if policies is not None: + _setter("policies", policies) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + """ + Name of the user group - should be unique in one account + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IdpGroupMappingPolicyArgs']]]]: + return pulumi.get(self, "policies") + + @policies.setter + def policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IdpGroupMappingPolicyArgs']]]]): + pulumi.set(self, "policies", value) + + +class IdpGroupMapping(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['IdpGroupMappingPolicyArgs']]]]] = None, + __props__=None): + """ + `IdpGroupMapping` represents a mapping (binding) between a user group (as provided by IdP) and a Spacelift User Management Policy. If you assign permissions (a Policy) to a user group, all users in the group will have those permissions unless the user's permissions are higher than the group's permissions. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + test = spacelift.IdpGroupMapping("test", policies=[ + spacelift.IdpGroupMappingPolicyArgs( + role="ADMIN", + space_id="root", + ), + spacelift.IdpGroupMappingPolicyArgs( + role="ADMIN", + space_id="legacy", + ), + ]) + ``` + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] name: Name of the user group - should be unique in one account + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: IdpGroupMappingArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `IdpGroupMapping` represents a mapping (binding) between a user group (as provided by IdP) and a Spacelift User Management Policy. If you assign permissions (a Policy) to a user group, all users in the group will have those permissions unless the user's permissions are higher than the group's permissions. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + test = spacelift.IdpGroupMapping("test", policies=[ + spacelift.IdpGroupMappingPolicyArgs( + role="ADMIN", + space_id="root", + ), + spacelift.IdpGroupMappingPolicyArgs( + role="ADMIN", + space_id="legacy", + ), + ]) + ``` + + :param str resource_name: The name of the resource. + :param IdpGroupMappingArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(IdpGroupMappingArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + IdpGroupMappingArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['IdpGroupMappingPolicyArgs']]]]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = IdpGroupMappingArgs.__new__(IdpGroupMappingArgs) + + __props__.__dict__["name"] = name + if policies is None and not opts.urn: + raise TypeError("Missing required property 'policies'") + __props__.__dict__["policies"] = policies + super(IdpGroupMapping, __self__).__init__( + 'spacelift:index/idpGroupMapping:IdpGroupMapping', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['IdpGroupMappingPolicyArgs']]]]] = None) -> 'IdpGroupMapping': + """ + Get an existing IdpGroupMapping resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] name: Name of the user group - should be unique in one account + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _IdpGroupMappingState.__new__(_IdpGroupMappingState) + + __props__.__dict__["name"] = name + __props__.__dict__["policies"] = policies + return IdpGroupMapping(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + """ + Name of the user group - should be unique in one account + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def policies(self) -> pulumi.Output[Sequence['outputs.IdpGroupMappingPolicy']]: + return pulumi.get(self, "policies") + diff --git a/sdk/python/pulumi_spacelift/module.py b/sdk/python/pulumi_spacelift/module.py index e7a8d5f..e414bc3 100644 --- a/sdk/python/pulumi_spacelift/module.py +++ b/sdk/python/pulumi_spacelift/module.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities from . import outputs from ._inputs import * @@ -23,6 +23,7 @@ def __init__(__self__, *, bitbucket_cloud: Optional[pulumi.Input['ModuleBitbucketCloudArgs']] = None, bitbucket_datacenter: Optional[pulumi.Input['ModuleBitbucketDatacenterArgs']] = None, description: Optional[pulumi.Input[str]] = None, + enable_local_preview: Optional[pulumi.Input[bool]] = None, github_enterprise: Optional[pulumi.Input['ModuleGithubEnterpriseArgs']] = None, gitlab: Optional[pulumi.Input['ModuleGitlabArgs']] = None, labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, @@ -32,7 +33,8 @@ def __init__(__self__, *, shared_accounts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, space_id: Optional[pulumi.Input[str]] = None, terraform_provider: Optional[pulumi.Input[str]] = None, - worker_pool_id: Optional[pulumi.Input[str]] = None): + worker_pool_id: Optional[pulumi.Input[str]] = None, + workflow_tool: Optional[pulumi.Input[str]] = None): """ The set of arguments for constructing a Module resource. :param pulumi.Input[str] branch: GitHub branch to apply changes to @@ -42,6 +44,7 @@ def __init__(__self__, *, :param pulumi.Input['ModuleBitbucketCloudArgs'] bitbucket_cloud: Bitbucket Cloud VCS settings :param pulumi.Input['ModuleBitbucketDatacenterArgs'] bitbucket_datacenter: Bitbucket Datacenter VCS settings :param pulumi.Input[str] description: Free-form module description for users + :param pulumi.Input[bool] enable_local_preview: Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. :param pulumi.Input['ModuleGithubEnterpriseArgs'] github_enterprise: GitHub Enterprise (self-hosted) VCS settings :param pulumi.Input['ModuleGitlabArgs'] gitlab: GitLab VCS settings :param pulumi.Input[str] name: The module name will by default be inferred from the repository name if it follows the terraform-provider-name naming @@ -54,40 +57,120 @@ def __init__(__self__, *, :param pulumi.Input[str] terraform_provider: The module provider will by default be inferred from the repository name if it follows the terraform-provider-name naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you can provide the provider name here. - :param pulumi.Input[str] worker_pool_id: ID of the worker pool to use - """ - pulumi.set(__self__, "branch", branch) - pulumi.set(__self__, "repository", repository) + :param pulumi.Input[str] worker_pool_id: ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. + :param pulumi.Input[str] workflow_tool: Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + """ + ModuleArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + branch=branch, + repository=repository, + administrative=administrative, + azure_devops=azure_devops, + bitbucket_cloud=bitbucket_cloud, + bitbucket_datacenter=bitbucket_datacenter, + description=description, + enable_local_preview=enable_local_preview, + github_enterprise=github_enterprise, + gitlab=gitlab, + labels=labels, + name=name, + project_root=project_root, + protect_from_deletion=protect_from_deletion, + shared_accounts=shared_accounts, + space_id=space_id, + terraform_provider=terraform_provider, + worker_pool_id=worker_pool_id, + workflow_tool=workflow_tool, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + branch: Optional[pulumi.Input[str]] = None, + repository: Optional[pulumi.Input[str]] = None, + administrative: Optional[pulumi.Input[bool]] = None, + azure_devops: Optional[pulumi.Input['ModuleAzureDevopsArgs']] = None, + bitbucket_cloud: Optional[pulumi.Input['ModuleBitbucketCloudArgs']] = None, + bitbucket_datacenter: Optional[pulumi.Input['ModuleBitbucketDatacenterArgs']] = None, + description: Optional[pulumi.Input[str]] = None, + enable_local_preview: Optional[pulumi.Input[bool]] = None, + github_enterprise: Optional[pulumi.Input['ModuleGithubEnterpriseArgs']] = None, + gitlab: Optional[pulumi.Input['ModuleGitlabArgs']] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + project_root: Optional[pulumi.Input[str]] = None, + protect_from_deletion: Optional[pulumi.Input[bool]] = None, + shared_accounts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + space_id: Optional[pulumi.Input[str]] = None, + terraform_provider: Optional[pulumi.Input[str]] = None, + worker_pool_id: Optional[pulumi.Input[str]] = None, + workflow_tool: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if branch is None: + raise TypeError("Missing 'branch' argument") + if repository is None: + raise TypeError("Missing 'repository' argument") + if azure_devops is None and 'azureDevops' in kwargs: + azure_devops = kwargs['azureDevops'] + if bitbucket_cloud is None and 'bitbucketCloud' in kwargs: + bitbucket_cloud = kwargs['bitbucketCloud'] + if bitbucket_datacenter is None and 'bitbucketDatacenter' in kwargs: + bitbucket_datacenter = kwargs['bitbucketDatacenter'] + if enable_local_preview is None and 'enableLocalPreview' in kwargs: + enable_local_preview = kwargs['enableLocalPreview'] + if github_enterprise is None and 'githubEnterprise' in kwargs: + github_enterprise = kwargs['githubEnterprise'] + if project_root is None and 'projectRoot' in kwargs: + project_root = kwargs['projectRoot'] + if protect_from_deletion is None and 'protectFromDeletion' in kwargs: + protect_from_deletion = kwargs['protectFromDeletion'] + if shared_accounts is None and 'sharedAccounts' in kwargs: + shared_accounts = kwargs['sharedAccounts'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if terraform_provider is None and 'terraformProvider' in kwargs: + terraform_provider = kwargs['terraformProvider'] + if worker_pool_id is None and 'workerPoolId' in kwargs: + worker_pool_id = kwargs['workerPoolId'] + if workflow_tool is None and 'workflowTool' in kwargs: + workflow_tool = kwargs['workflowTool'] + + _setter("branch", branch) + _setter("repository", repository) if administrative is not None: - pulumi.set(__self__, "administrative", administrative) + _setter("administrative", administrative) if azure_devops is not None: - pulumi.set(__self__, "azure_devops", azure_devops) + _setter("azure_devops", azure_devops) if bitbucket_cloud is not None: - pulumi.set(__self__, "bitbucket_cloud", bitbucket_cloud) + _setter("bitbucket_cloud", bitbucket_cloud) if bitbucket_datacenter is not None: - pulumi.set(__self__, "bitbucket_datacenter", bitbucket_datacenter) + _setter("bitbucket_datacenter", bitbucket_datacenter) if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) + if enable_local_preview is not None: + _setter("enable_local_preview", enable_local_preview) if github_enterprise is not None: - pulumi.set(__self__, "github_enterprise", github_enterprise) + _setter("github_enterprise", github_enterprise) if gitlab is not None: - pulumi.set(__self__, "gitlab", gitlab) + _setter("gitlab", gitlab) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if project_root is not None: - pulumi.set(__self__, "project_root", project_root) + _setter("project_root", project_root) if protect_from_deletion is not None: - pulumi.set(__self__, "protect_from_deletion", protect_from_deletion) + _setter("protect_from_deletion", protect_from_deletion) if shared_accounts is not None: - pulumi.set(__self__, "shared_accounts", shared_accounts) + _setter("shared_accounts", shared_accounts) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) if terraform_provider is not None: - pulumi.set(__self__, "terraform_provider", terraform_provider) + _setter("terraform_provider", terraform_provider) if worker_pool_id is not None: - pulumi.set(__self__, "worker_pool_id", worker_pool_id) + _setter("worker_pool_id", worker_pool_id) + if workflow_tool is not None: + _setter("workflow_tool", workflow_tool) @property @pulumi.getter @@ -173,6 +256,18 @@ def description(self) -> Optional[pulumi.Input[str]]: def description(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "description", value) + @property + @pulumi.getter(name="enableLocalPreview") + def enable_local_preview(self) -> Optional[pulumi.Input[bool]]: + """ + Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + """ + return pulumi.get(self, "enable_local_preview") + + @enable_local_preview.setter + def enable_local_preview(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "enable_local_preview", value) + @property @pulumi.getter(name="githubEnterprise") def github_enterprise(self) -> Optional[pulumi.Input['ModuleGithubEnterpriseArgs']]: @@ -286,7 +381,7 @@ def terraform_provider(self, value: Optional[pulumi.Input[str]]): @pulumi.getter(name="workerPoolId") def worker_pool_id(self) -> Optional[pulumi.Input[str]]: """ - ID of the worker pool to use + ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. """ return pulumi.get(self, "worker_pool_id") @@ -294,6 +389,18 @@ def worker_pool_id(self) -> Optional[pulumi.Input[str]]: def worker_pool_id(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "worker_pool_id", value) + @property + @pulumi.getter(name="workflowTool") + def workflow_tool(self) -> Optional[pulumi.Input[str]]: + """ + Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + """ + return pulumi.get(self, "workflow_tool") + + @workflow_tool.setter + def workflow_tool(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "workflow_tool", value) + @pulumi.input_type class _ModuleState: @@ -305,6 +412,7 @@ def __init__(__self__, *, bitbucket_datacenter: Optional[pulumi.Input['ModuleBitbucketDatacenterArgs']] = None, branch: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, + enable_local_preview: Optional[pulumi.Input[bool]] = None, github_enterprise: Optional[pulumi.Input['ModuleGithubEnterpriseArgs']] = None, gitlab: Optional[pulumi.Input['ModuleGitlabArgs']] = None, labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, @@ -315,7 +423,8 @@ def __init__(__self__, *, shared_accounts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, space_id: Optional[pulumi.Input[str]] = None, terraform_provider: Optional[pulumi.Input[str]] = None, - worker_pool_id: Optional[pulumi.Input[str]] = None): + worker_pool_id: Optional[pulumi.Input[str]] = None, + workflow_tool: Optional[pulumi.Input[str]] = None): """ Input properties used for looking up and filtering Module resources. :param pulumi.Input[bool] administrative: Indicates whether this module can manage others. Defaults to `false`. @@ -325,6 +434,7 @@ def __init__(__self__, *, :param pulumi.Input['ModuleBitbucketDatacenterArgs'] bitbucket_datacenter: Bitbucket Datacenter VCS settings :param pulumi.Input[str] branch: GitHub branch to apply changes to :param pulumi.Input[str] description: Free-form module description for users + :param pulumi.Input[bool] enable_local_preview: Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. :param pulumi.Input['ModuleGithubEnterpriseArgs'] github_enterprise: GitHub Enterprise (self-hosted) VCS settings :param pulumi.Input['ModuleGitlabArgs'] gitlab: GitLab VCS settings :param pulumi.Input[str] name: The module name will by default be inferred from the repository name if it follows the terraform-provider-name naming @@ -338,44 +448,124 @@ def __init__(__self__, *, :param pulumi.Input[str] terraform_provider: The module provider will by default be inferred from the repository name if it follows the terraform-provider-name naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you can provide the provider name here. - :param pulumi.Input[str] worker_pool_id: ID of the worker pool to use - """ + :param pulumi.Input[str] worker_pool_id: ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. + :param pulumi.Input[str] workflow_tool: Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + """ + _ModuleState._configure( + lambda key, value: pulumi.set(__self__, key, value), + administrative=administrative, + aws_assume_role_policy_statement=aws_assume_role_policy_statement, + azure_devops=azure_devops, + bitbucket_cloud=bitbucket_cloud, + bitbucket_datacenter=bitbucket_datacenter, + branch=branch, + description=description, + enable_local_preview=enable_local_preview, + github_enterprise=github_enterprise, + gitlab=gitlab, + labels=labels, + name=name, + project_root=project_root, + protect_from_deletion=protect_from_deletion, + repository=repository, + shared_accounts=shared_accounts, + space_id=space_id, + terraform_provider=terraform_provider, + worker_pool_id=worker_pool_id, + workflow_tool=workflow_tool, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + administrative: Optional[pulumi.Input[bool]] = None, + aws_assume_role_policy_statement: Optional[pulumi.Input[str]] = None, + azure_devops: Optional[pulumi.Input['ModuleAzureDevopsArgs']] = None, + bitbucket_cloud: Optional[pulumi.Input['ModuleBitbucketCloudArgs']] = None, + bitbucket_datacenter: Optional[pulumi.Input['ModuleBitbucketDatacenterArgs']] = None, + branch: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + enable_local_preview: Optional[pulumi.Input[bool]] = None, + github_enterprise: Optional[pulumi.Input['ModuleGithubEnterpriseArgs']] = None, + gitlab: Optional[pulumi.Input['ModuleGitlabArgs']] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + project_root: Optional[pulumi.Input[str]] = None, + protect_from_deletion: Optional[pulumi.Input[bool]] = None, + repository: Optional[pulumi.Input[str]] = None, + shared_accounts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + space_id: Optional[pulumi.Input[str]] = None, + terraform_provider: Optional[pulumi.Input[str]] = None, + worker_pool_id: Optional[pulumi.Input[str]] = None, + workflow_tool: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if aws_assume_role_policy_statement is None and 'awsAssumeRolePolicyStatement' in kwargs: + aws_assume_role_policy_statement = kwargs['awsAssumeRolePolicyStatement'] + if azure_devops is None and 'azureDevops' in kwargs: + azure_devops = kwargs['azureDevops'] + if bitbucket_cloud is None and 'bitbucketCloud' in kwargs: + bitbucket_cloud = kwargs['bitbucketCloud'] + if bitbucket_datacenter is None and 'bitbucketDatacenter' in kwargs: + bitbucket_datacenter = kwargs['bitbucketDatacenter'] + if enable_local_preview is None and 'enableLocalPreview' in kwargs: + enable_local_preview = kwargs['enableLocalPreview'] + if github_enterprise is None and 'githubEnterprise' in kwargs: + github_enterprise = kwargs['githubEnterprise'] + if project_root is None and 'projectRoot' in kwargs: + project_root = kwargs['projectRoot'] + if protect_from_deletion is None and 'protectFromDeletion' in kwargs: + protect_from_deletion = kwargs['protectFromDeletion'] + if shared_accounts is None and 'sharedAccounts' in kwargs: + shared_accounts = kwargs['sharedAccounts'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if terraform_provider is None and 'terraformProvider' in kwargs: + terraform_provider = kwargs['terraformProvider'] + if worker_pool_id is None and 'workerPoolId' in kwargs: + worker_pool_id = kwargs['workerPoolId'] + if workflow_tool is None and 'workflowTool' in kwargs: + workflow_tool = kwargs['workflowTool'] + if administrative is not None: - pulumi.set(__self__, "administrative", administrative) + _setter("administrative", administrative) if aws_assume_role_policy_statement is not None: - pulumi.set(__self__, "aws_assume_role_policy_statement", aws_assume_role_policy_statement) + _setter("aws_assume_role_policy_statement", aws_assume_role_policy_statement) if azure_devops is not None: - pulumi.set(__self__, "azure_devops", azure_devops) + _setter("azure_devops", azure_devops) if bitbucket_cloud is not None: - pulumi.set(__self__, "bitbucket_cloud", bitbucket_cloud) + _setter("bitbucket_cloud", bitbucket_cloud) if bitbucket_datacenter is not None: - pulumi.set(__self__, "bitbucket_datacenter", bitbucket_datacenter) + _setter("bitbucket_datacenter", bitbucket_datacenter) if branch is not None: - pulumi.set(__self__, "branch", branch) + _setter("branch", branch) if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) + if enable_local_preview is not None: + _setter("enable_local_preview", enable_local_preview) if github_enterprise is not None: - pulumi.set(__self__, "github_enterprise", github_enterprise) + _setter("github_enterprise", github_enterprise) if gitlab is not None: - pulumi.set(__self__, "gitlab", gitlab) + _setter("gitlab", gitlab) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if project_root is not None: - pulumi.set(__self__, "project_root", project_root) + _setter("project_root", project_root) if protect_from_deletion is not None: - pulumi.set(__self__, "protect_from_deletion", protect_from_deletion) + _setter("protect_from_deletion", protect_from_deletion) if repository is not None: - pulumi.set(__self__, "repository", repository) + _setter("repository", repository) if shared_accounts is not None: - pulumi.set(__self__, "shared_accounts", shared_accounts) + _setter("shared_accounts", shared_accounts) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) if terraform_provider is not None: - pulumi.set(__self__, "terraform_provider", terraform_provider) + _setter("terraform_provider", terraform_provider) if worker_pool_id is not None: - pulumi.set(__self__, "worker_pool_id", worker_pool_id) + _setter("worker_pool_id", worker_pool_id) + if workflow_tool is not None: + _setter("workflow_tool", workflow_tool) @property @pulumi.getter @@ -461,6 +651,18 @@ def description(self) -> Optional[pulumi.Input[str]]: def description(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "description", value) + @property + @pulumi.getter(name="enableLocalPreview") + def enable_local_preview(self) -> Optional[pulumi.Input[bool]]: + """ + Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + """ + return pulumi.get(self, "enable_local_preview") + + @enable_local_preview.setter + def enable_local_preview(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "enable_local_preview", value) + @property @pulumi.getter(name="githubEnterprise") def github_enterprise(self) -> Optional[pulumi.Input['ModuleGithubEnterpriseArgs']]: @@ -586,7 +788,7 @@ def terraform_provider(self, value: Optional[pulumi.Input[str]]): @pulumi.getter(name="workerPoolId") def worker_pool_id(self) -> Optional[pulumi.Input[str]]: """ - ID of the worker pool to use + ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. """ return pulumi.get(self, "worker_pool_id") @@ -594,6 +796,18 @@ def worker_pool_id(self) -> Optional[pulumi.Input[str]]: def worker_pool_id(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "worker_pool_id", value) + @property + @pulumi.getter(name="workflowTool") + def workflow_tool(self) -> Optional[pulumi.Input[str]]: + """ + Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + """ + return pulumi.get(self, "workflow_tool") + + @workflow_tool.setter + def workflow_tool(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "workflow_tool", value) + class Module(pulumi.CustomResource): @overload @@ -606,6 +820,7 @@ def __init__(__self__, bitbucket_datacenter: Optional[pulumi.Input[pulumi.InputType['ModuleBitbucketDatacenterArgs']]] = None, branch: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, + enable_local_preview: Optional[pulumi.Input[bool]] = None, github_enterprise: Optional[pulumi.Input[pulumi.InputType['ModuleGithubEnterpriseArgs']]] = None, gitlab: Optional[pulumi.Input[pulumi.InputType['ModuleGitlabArgs']]] = None, labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, @@ -617,6 +832,7 @@ def __init__(__self__, space_id: Optional[pulumi.Input[str]] = None, terraform_provider: Optional[pulumi.Input[str]] = None, worker_pool_id: Optional[pulumi.Input[str]] = None, + workflow_tool: Optional[pulumi.Input[str]] = None, __props__=None): """ ## Example Usage @@ -655,6 +871,7 @@ def __init__(__self__, :param pulumi.Input[pulumi.InputType['ModuleBitbucketDatacenterArgs']] bitbucket_datacenter: Bitbucket Datacenter VCS settings :param pulumi.Input[str] branch: GitHub branch to apply changes to :param pulumi.Input[str] description: Free-form module description for users + :param pulumi.Input[bool] enable_local_preview: Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. :param pulumi.Input[pulumi.InputType['ModuleGithubEnterpriseArgs']] github_enterprise: GitHub Enterprise (self-hosted) VCS settings :param pulumi.Input[pulumi.InputType['ModuleGitlabArgs']] gitlab: GitLab VCS settings :param pulumi.Input[str] name: The module name will by default be inferred from the repository name if it follows the terraform-provider-name naming @@ -668,7 +885,8 @@ def __init__(__self__, :param pulumi.Input[str] terraform_provider: The module provider will by default be inferred from the repository name if it follows the terraform-provider-name naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you can provide the provider name here. - :param pulumi.Input[str] worker_pool_id: ID of the worker pool to use + :param pulumi.Input[str] worker_pool_id: ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. + :param pulumi.Input[str] workflow_tool: Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. """ ... @overload @@ -715,6 +933,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + ModuleArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -726,6 +948,7 @@ def _internal_init(__self__, bitbucket_datacenter: Optional[pulumi.Input[pulumi.InputType['ModuleBitbucketDatacenterArgs']]] = None, branch: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, + enable_local_preview: Optional[pulumi.Input[bool]] = None, github_enterprise: Optional[pulumi.Input[pulumi.InputType['ModuleGithubEnterpriseArgs']]] = None, gitlab: Optional[pulumi.Input[pulumi.InputType['ModuleGitlabArgs']]] = None, labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, @@ -737,6 +960,7 @@ def _internal_init(__self__, space_id: Optional[pulumi.Input[str]] = None, terraform_provider: Optional[pulumi.Input[str]] = None, worker_pool_id: Optional[pulumi.Input[str]] = None, + workflow_tool: Optional[pulumi.Input[str]] = None, __props__=None): opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) if not isinstance(opts, pulumi.ResourceOptions): @@ -747,14 +971,20 @@ def _internal_init(__self__, __props__ = ModuleArgs.__new__(ModuleArgs) __props__.__dict__["administrative"] = administrative + azure_devops = _utilities.configure(azure_devops, ModuleAzureDevopsArgs, True) __props__.__dict__["azure_devops"] = azure_devops + bitbucket_cloud = _utilities.configure(bitbucket_cloud, ModuleBitbucketCloudArgs, True) __props__.__dict__["bitbucket_cloud"] = bitbucket_cloud + bitbucket_datacenter = _utilities.configure(bitbucket_datacenter, ModuleBitbucketDatacenterArgs, True) __props__.__dict__["bitbucket_datacenter"] = bitbucket_datacenter if branch is None and not opts.urn: raise TypeError("Missing required property 'branch'") __props__.__dict__["branch"] = branch __props__.__dict__["description"] = description + __props__.__dict__["enable_local_preview"] = enable_local_preview + github_enterprise = _utilities.configure(github_enterprise, ModuleGithubEnterpriseArgs, True) __props__.__dict__["github_enterprise"] = github_enterprise + gitlab = _utilities.configure(gitlab, ModuleGitlabArgs, True) __props__.__dict__["gitlab"] = gitlab __props__.__dict__["labels"] = labels __props__.__dict__["name"] = name @@ -767,6 +997,7 @@ def _internal_init(__self__, __props__.__dict__["space_id"] = space_id __props__.__dict__["terraform_provider"] = terraform_provider __props__.__dict__["worker_pool_id"] = worker_pool_id + __props__.__dict__["workflow_tool"] = workflow_tool __props__.__dict__["aws_assume_role_policy_statement"] = None super(Module, __self__).__init__( 'spacelift:index/module:Module', @@ -785,6 +1016,7 @@ def get(resource_name: str, bitbucket_datacenter: Optional[pulumi.Input[pulumi.InputType['ModuleBitbucketDatacenterArgs']]] = None, branch: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, + enable_local_preview: Optional[pulumi.Input[bool]] = None, github_enterprise: Optional[pulumi.Input[pulumi.InputType['ModuleGithubEnterpriseArgs']]] = None, gitlab: Optional[pulumi.Input[pulumi.InputType['ModuleGitlabArgs']]] = None, labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, @@ -795,7 +1027,8 @@ def get(resource_name: str, shared_accounts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, space_id: Optional[pulumi.Input[str]] = None, terraform_provider: Optional[pulumi.Input[str]] = None, - worker_pool_id: Optional[pulumi.Input[str]] = None) -> 'Module': + worker_pool_id: Optional[pulumi.Input[str]] = None, + workflow_tool: Optional[pulumi.Input[str]] = None) -> 'Module': """ Get an existing Module resource's state with the given name, id, and optional extra properties used to qualify the lookup. @@ -810,6 +1043,7 @@ def get(resource_name: str, :param pulumi.Input[pulumi.InputType['ModuleBitbucketDatacenterArgs']] bitbucket_datacenter: Bitbucket Datacenter VCS settings :param pulumi.Input[str] branch: GitHub branch to apply changes to :param pulumi.Input[str] description: Free-form module description for users + :param pulumi.Input[bool] enable_local_preview: Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. :param pulumi.Input[pulumi.InputType['ModuleGithubEnterpriseArgs']] github_enterprise: GitHub Enterprise (self-hosted) VCS settings :param pulumi.Input[pulumi.InputType['ModuleGitlabArgs']] gitlab: GitLab VCS settings :param pulumi.Input[str] name: The module name will by default be inferred from the repository name if it follows the terraform-provider-name naming @@ -823,7 +1057,8 @@ def get(resource_name: str, :param pulumi.Input[str] terraform_provider: The module provider will by default be inferred from the repository name if it follows the terraform-provider-name naming convention. However, if the repository doesn't follow this convention, or you gave the module a custom name, you can provide the provider name here. - :param pulumi.Input[str] worker_pool_id: ID of the worker pool to use + :param pulumi.Input[str] worker_pool_id: ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. + :param pulumi.Input[str] workflow_tool: Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. """ opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) @@ -836,6 +1071,7 @@ def get(resource_name: str, __props__.__dict__["bitbucket_datacenter"] = bitbucket_datacenter __props__.__dict__["branch"] = branch __props__.__dict__["description"] = description + __props__.__dict__["enable_local_preview"] = enable_local_preview __props__.__dict__["github_enterprise"] = github_enterprise __props__.__dict__["gitlab"] = gitlab __props__.__dict__["labels"] = labels @@ -847,6 +1083,7 @@ def get(resource_name: str, __props__.__dict__["space_id"] = space_id __props__.__dict__["terraform_provider"] = terraform_provider __props__.__dict__["worker_pool_id"] = worker_pool_id + __props__.__dict__["workflow_tool"] = workflow_tool return Module(resource_name, opts=opts, __props__=__props__) @property @@ -905,6 +1142,14 @@ def description(self) -> pulumi.Output[Optional[str]]: """ return pulumi.get(self, "description") + @property + @pulumi.getter(name="enableLocalPreview") + def enable_local_preview(self) -> pulumi.Output[Optional[bool]]: + """ + Indicates whether local preview versions can be triggered on this Module. Defaults to `false`. + """ + return pulumi.get(self, "enable_local_preview") + @property @pulumi.getter(name="githubEnterprise") def github_enterprise(self) -> pulumi.Output[Optional['outputs.ModuleGithubEnterprise']]: @@ -990,7 +1235,15 @@ def terraform_provider(self) -> pulumi.Output[str]: @pulumi.getter(name="workerPoolId") def worker_pool_id(self) -> pulumi.Output[Optional[str]]: """ - ID of the worker pool to use + ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. """ return pulumi.get(self, "worker_pool_id") + @property + @pulumi.getter(name="workflowTool") + def workflow_tool(self) -> pulumi.Output[str]: + """ + Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + """ + return pulumi.get(self, "workflow_tool") + diff --git a/sdk/python/pulumi_spacelift/mountedfile.py b/sdk/python/pulumi_spacelift/mountedfile.py index eb06863..8180c1c 100644 --- a/sdk/python/pulumi_spacelift/mountedfile.py +++ b/sdk/python/pulumi_spacelift/mountedfile.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['MountedfileArgs', 'Mountedfile'] @@ -29,16 +29,51 @@ def __init__(__self__, *, :param pulumi.Input[str] stack_id: ID of the stack on which the mounted file is defined :param pulumi.Input[bool] write_only: Indicates whether the content can be read back outside a Run. Defaults to `true`. """ - pulumi.set(__self__, "content", content) - pulumi.set(__self__, "relative_path", relative_path) + MountedfileArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + content=content, + relative_path=relative_path, + context_id=context_id, + module_id=module_id, + stack_id=stack_id, + write_only=write_only, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + content: Optional[pulumi.Input[str]] = None, + relative_path: Optional[pulumi.Input[str]] = None, + context_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + write_only: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if content is None: + raise TypeError("Missing 'content' argument") + if relative_path is None and 'relativePath' in kwargs: + relative_path = kwargs['relativePath'] + if relative_path is None: + raise TypeError("Missing 'relative_path' argument") + if context_id is None and 'contextId' in kwargs: + context_id = kwargs['contextId'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if write_only is None and 'writeOnly' in kwargs: + write_only = kwargs['writeOnly'] + + _setter("content", content) + _setter("relative_path", relative_path) if context_id is not None: - pulumi.set(__self__, "context_id", context_id) + _setter("context_id", context_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if write_only is not None: - pulumi.set(__self__, "write_only", write_only) + _setter("write_only", write_only) @property @pulumi.getter @@ -133,20 +168,53 @@ def __init__(__self__, *, :param pulumi.Input[str] stack_id: ID of the stack on which the mounted file is defined :param pulumi.Input[bool] write_only: Indicates whether the content can be read back outside a Run. Defaults to `true`. """ + _MountedfileState._configure( + lambda key, value: pulumi.set(__self__, key, value), + checksum=checksum, + content=content, + context_id=context_id, + module_id=module_id, + relative_path=relative_path, + stack_id=stack_id, + write_only=write_only, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + checksum: Optional[pulumi.Input[str]] = None, + content: Optional[pulumi.Input[str]] = None, + context_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + relative_path: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + write_only: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if context_id is None and 'contextId' in kwargs: + context_id = kwargs['contextId'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if relative_path is None and 'relativePath' in kwargs: + relative_path = kwargs['relativePath'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if write_only is None and 'writeOnly' in kwargs: + write_only = kwargs['writeOnly'] + if checksum is not None: - pulumi.set(__self__, "checksum", checksum) + _setter("checksum", checksum) if content is not None: - pulumi.set(__self__, "content", content) + _setter("content", content) if context_id is not None: - pulumi.set(__self__, "context_id", context_id) + _setter("context_id", context_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if relative_path is not None: - pulumi.set(__self__, "relative_path", relative_path) + _setter("relative_path", relative_path) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if write_only is not None: - pulumi.set(__self__, "write_only", write_only) + _setter("write_only", write_only) @property @pulumi.getter @@ -352,6 +420,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + MountedfileArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -374,7 +446,7 @@ def _internal_init(__self__, if content is None and not opts.urn: raise TypeError("Missing required property 'content'") - __props__.__dict__["content"] = content + __props__.__dict__["content"] = None if content is None else pulumi.Output.secret(content) __props__.__dict__["context_id"] = context_id __props__.__dict__["module_id"] = module_id if relative_path is None and not opts.urn: @@ -383,6 +455,8 @@ def _internal_init(__self__, __props__.__dict__["stack_id"] = stack_id __props__.__dict__["write_only"] = write_only __props__.__dict__["checksum"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["content"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) super(Mountedfile, __self__).__init__( 'spacelift:index/mountedfile:Mountedfile', resource_name, diff --git a/sdk/python/pulumi_spacelift/named_webhook.py b/sdk/python/pulumi_spacelift/named_webhook.py new file mode 100644 index 0000000..0afd57f --- /dev/null +++ b/sdk/python/pulumi_spacelift/named_webhook.py @@ -0,0 +1,441 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['NamedWebhookArgs', 'NamedWebhook'] + +@pulumi.input_type +class NamedWebhookArgs: + def __init__(__self__, *, + enabled: pulumi.Input[bool], + endpoint: pulumi.Input[str], + space_id: pulumi.Input[str], + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a NamedWebhook resource. + :param pulumi.Input[bool] enabled: enables or disables sending webhooks. + :param pulumi.Input[str] endpoint: endpoint to send the requests to + :param pulumi.Input[str] space_id: ID of the space the webhook is in + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: labels for the webhook to use when referring in policies or filtering them + :param pulumi.Input[str] name: the name for the webhook which will also be used to generate the id + :param pulumi.Input[str] secret: secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + """ + NamedWebhookArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + enabled=enabled, + endpoint=endpoint, + space_id=space_id, + labels=labels, + name=name, + secret=secret, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + enabled: Optional[pulumi.Input[bool]] = None, + endpoint: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if enabled is None: + raise TypeError("Missing 'enabled' argument") + if endpoint is None: + raise TypeError("Missing 'endpoint' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + + _setter("enabled", enabled) + _setter("endpoint", endpoint) + _setter("space_id", space_id) + if labels is not None: + _setter("labels", labels) + if name is not None: + _setter("name", name) + if secret is not None: + _setter("secret", secret) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Input[bool]: + """ + enables or disables sending webhooks. + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: pulumi.Input[bool]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter + def endpoint(self) -> pulumi.Input[str]: + """ + endpoint to send the requests to + """ + return pulumi.get(self, "endpoint") + + @endpoint.setter + def endpoint(self, value: pulumi.Input[str]): + pulumi.set(self, "endpoint", value) + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> pulumi.Input[str]: + """ + ID of the space the webhook is in + """ + return pulumi.get(self, "space_id") + + @space_id.setter + def space_id(self, value: pulumi.Input[str]): + pulumi.set(self, "space_id", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + """ + labels for the webhook to use when referring in policies or filtering them + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + """ + the name for the webhook which will also be used to generate the id + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def secret(self) -> Optional[pulumi.Input[str]]: + """ + secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + """ + return pulumi.get(self, "secret") + + @secret.setter + def secret(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "secret", value) + + +@pulumi.input_type +class _NamedWebhookState: + def __init__(__self__, *, + enabled: Optional[pulumi.Input[bool]] = None, + endpoint: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering NamedWebhook resources. + :param pulumi.Input[bool] enabled: enables or disables sending webhooks. + :param pulumi.Input[str] endpoint: endpoint to send the requests to + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: labels for the webhook to use when referring in policies or filtering them + :param pulumi.Input[str] name: the name for the webhook which will also be used to generate the id + :param pulumi.Input[str] secret: secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + :param pulumi.Input[str] space_id: ID of the space the webhook is in + """ + _NamedWebhookState._configure( + lambda key, value: pulumi.set(__self__, key, value), + enabled=enabled, + endpoint=endpoint, + labels=labels, + name=name, + secret=secret, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + enabled: Optional[pulumi.Input[bool]] = None, + endpoint: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + + if enabled is not None: + _setter("enabled", enabled) + if endpoint is not None: + _setter("endpoint", endpoint) + if labels is not None: + _setter("labels", labels) + if name is not None: + _setter("name", name) + if secret is not None: + _setter("secret", secret) + if space_id is not None: + _setter("space_id", space_id) + + @property + @pulumi.getter + def enabled(self) -> Optional[pulumi.Input[bool]]: + """ + enables or disables sending webhooks. + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter + def endpoint(self) -> Optional[pulumi.Input[str]]: + """ + endpoint to send the requests to + """ + return pulumi.get(self, "endpoint") + + @endpoint.setter + def endpoint(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "endpoint", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + """ + labels for the webhook to use when referring in policies or filtering them + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + """ + the name for the webhook which will also be used to generate the id + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def secret(self) -> Optional[pulumi.Input[str]]: + """ + secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + """ + return pulumi.get(self, "secret") + + @secret.setter + def secret(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "secret", value) + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the space the webhook is in + """ + return pulumi.get(self, "space_id") + + @space_id.setter + def space_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "space_id", value) + + +class NamedWebhook(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[bool]] = None, + endpoint: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[bool] enabled: enables or disables sending webhooks. + :param pulumi.Input[str] endpoint: endpoint to send the requests to + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: labels for the webhook to use when referring in policies or filtering them + :param pulumi.Input[str] name: the name for the webhook which will also be used to generate the id + :param pulumi.Input[str] secret: secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + :param pulumi.Input[str] space_id: ID of the space the webhook is in + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: NamedWebhookArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `NamedWebhook` represents a named webhook endpoint used for creating webhookswhich are referred to in Notification policies to route messages. + + :param str resource_name: The name of the resource. + :param NamedWebhookArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(NamedWebhookArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + NamedWebhookArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[bool]] = None, + endpoint: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = NamedWebhookArgs.__new__(NamedWebhookArgs) + + if enabled is None and not opts.urn: + raise TypeError("Missing required property 'enabled'") + __props__.__dict__["enabled"] = enabled + if endpoint is None and not opts.urn: + raise TypeError("Missing required property 'endpoint'") + __props__.__dict__["endpoint"] = endpoint + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["secret"] = None if secret is None else pulumi.Output.secret(secret) + if space_id is None and not opts.urn: + raise TypeError("Missing required property 'space_id'") + __props__.__dict__["space_id"] = space_id + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["secret"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(NamedWebhook, __self__).__init__( + 'spacelift:index/namedWebhook:NamedWebhook', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[bool]] = None, + endpoint: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None) -> 'NamedWebhook': + """ + Get an existing NamedWebhook resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[bool] enabled: enables or disables sending webhooks. + :param pulumi.Input[str] endpoint: endpoint to send the requests to + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: labels for the webhook to use when referring in policies or filtering them + :param pulumi.Input[str] name: the name for the webhook which will also be used to generate the id + :param pulumi.Input[str] secret: secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + :param pulumi.Input[str] space_id: ID of the space the webhook is in + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _NamedWebhookState.__new__(_NamedWebhookState) + + __props__.__dict__["enabled"] = enabled + __props__.__dict__["endpoint"] = endpoint + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["secret"] = secret + __props__.__dict__["space_id"] = space_id + return NamedWebhook(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Output[bool]: + """ + enables or disables sending webhooks. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter + def endpoint(self) -> pulumi.Output[str]: + """ + endpoint to send the requests to + """ + return pulumi.get(self, "endpoint") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Sequence[str]]]: + """ + labels for the webhook to use when referring in policies or filtering them + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + """ + the name for the webhook which will also be used to generate the id + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def secret(self) -> pulumi.Output[Optional[str]]: + """ + secret used to sign each request so you're able to verify that the request comes from us. Defaults to an empty value. + """ + return pulumi.get(self, "secret") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> pulumi.Output[str]: + """ + ID of the space the webhook is in + """ + return pulumi.get(self, "space_id") + diff --git a/sdk/python/pulumi_spacelift/named_webhook_secret_header.py b/sdk/python/pulumi_spacelift/named_webhook_secret_header.py new file mode 100644 index 0000000..0e4fe7a --- /dev/null +++ b/sdk/python/pulumi_spacelift/named_webhook_secret_header.py @@ -0,0 +1,288 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['NamedWebhookSecretHeaderArgs', 'NamedWebhookSecretHeader'] + +@pulumi.input_type +class NamedWebhookSecretHeaderArgs: + def __init__(__self__, *, + key: pulumi.Input[str], + value: pulumi.Input[str], + webhook_id: pulumi.Input[str]): + """ + The set of arguments for constructing a NamedWebhookSecretHeader resource. + :param pulumi.Input[str] key: key for the header + :param pulumi.Input[str] value: value for the header + :param pulumi.Input[str] webhook_id: ID of the stack on which the environment variable is defined + """ + NamedWebhookSecretHeaderArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + key=key, + value=value, + webhook_id=webhook_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + key: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, + webhook_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if key is None: + raise TypeError("Missing 'key' argument") + if value is None: + raise TypeError("Missing 'value' argument") + if webhook_id is None and 'webhookId' in kwargs: + webhook_id = kwargs['webhookId'] + if webhook_id is None: + raise TypeError("Missing 'webhook_id' argument") + + _setter("key", key) + _setter("value", value) + _setter("webhook_id", webhook_id) + + @property + @pulumi.getter + def key(self) -> pulumi.Input[str]: + """ + key for the header + """ + return pulumi.get(self, "key") + + @key.setter + def key(self, value: pulumi.Input[str]): + pulumi.set(self, "key", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + """ + value for the header + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter(name="webhookId") + def webhook_id(self) -> pulumi.Input[str]: + """ + ID of the stack on which the environment variable is defined + """ + return pulumi.get(self, "webhook_id") + + @webhook_id.setter + def webhook_id(self, value: pulumi.Input[str]): + pulumi.set(self, "webhook_id", value) + + +@pulumi.input_type +class _NamedWebhookSecretHeaderState: + def __init__(__self__, *, + key: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, + webhook_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering NamedWebhookSecretHeader resources. + :param pulumi.Input[str] key: key for the header + :param pulumi.Input[str] value: value for the header + :param pulumi.Input[str] webhook_id: ID of the stack on which the environment variable is defined + """ + _NamedWebhookSecretHeaderState._configure( + lambda key, value: pulumi.set(__self__, key, value), + key=key, + value=value, + webhook_id=webhook_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + key: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, + webhook_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if webhook_id is None and 'webhookId' in kwargs: + webhook_id = kwargs['webhookId'] + + if key is not None: + _setter("key", key) + if value is not None: + _setter("value", value) + if webhook_id is not None: + _setter("webhook_id", webhook_id) + + @property + @pulumi.getter + def key(self) -> Optional[pulumi.Input[str]]: + """ + key for the header + """ + return pulumi.get(self, "key") + + @key.setter + def key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "key", value) + + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[str]]: + """ + value for the header + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter(name="webhookId") + def webhook_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the stack on which the environment variable is defined + """ + return pulumi.get(self, "webhook_id") + + @webhook_id.setter + def webhook_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "webhook_id", value) + + +class NamedWebhookSecretHeader(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + key: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, + webhook_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `NamedWebhookSecretHeader` represents secret key value combination used as a custom headerwhen delivering webhook requests. It depends on `NamedWebhook` resource which should exist. + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] key: key for the header + :param pulumi.Input[str] value: value for the header + :param pulumi.Input[str] webhook_id: ID of the stack on which the environment variable is defined + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: NamedWebhookSecretHeaderArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `NamedWebhookSecretHeader` represents secret key value combination used as a custom headerwhen delivering webhook requests. It depends on `NamedWebhook` resource which should exist. + + :param str resource_name: The name of the resource. + :param NamedWebhookSecretHeaderArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(NamedWebhookSecretHeaderArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + NamedWebhookSecretHeaderArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + key: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, + webhook_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = NamedWebhookSecretHeaderArgs.__new__(NamedWebhookSecretHeaderArgs) + + if key is None and not opts.urn: + raise TypeError("Missing required property 'key'") + __props__.__dict__["key"] = key + if value is None and not opts.urn: + raise TypeError("Missing required property 'value'") + __props__.__dict__["value"] = None if value is None else pulumi.Output.secret(value) + if webhook_id is None and not opts.urn: + raise TypeError("Missing required property 'webhook_id'") + __props__.__dict__["webhook_id"] = webhook_id + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["value"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(NamedWebhookSecretHeader, __self__).__init__( + 'spacelift:index/namedWebhookSecretHeader:NamedWebhookSecretHeader', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + key: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None, + webhook_id: Optional[pulumi.Input[str]] = None) -> 'NamedWebhookSecretHeader': + """ + Get an existing NamedWebhookSecretHeader resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] key: key for the header + :param pulumi.Input[str] value: value for the header + :param pulumi.Input[str] webhook_id: ID of the stack on which the environment variable is defined + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _NamedWebhookSecretHeaderState.__new__(_NamedWebhookSecretHeaderState) + + __props__.__dict__["key"] = key + __props__.__dict__["value"] = value + __props__.__dict__["webhook_id"] = webhook_id + return NamedWebhookSecretHeader(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def key(self) -> pulumi.Output[str]: + """ + key for the header + """ + return pulumi.get(self, "key") + + @property + @pulumi.getter + def value(self) -> pulumi.Output[str]: + """ + value for the header + """ + return pulumi.get(self, "value") + + @property + @pulumi.getter(name="webhookId") + def webhook_id(self) -> pulumi.Output[str]: + """ + ID of the stack on which the environment variable is defined + """ + return pulumi.get(self, "webhook_id") + diff --git a/sdk/python/pulumi_spacelift/outputs.py b/sdk/python/pulumi_spacelift/outputs.py index c9b7800..3e316f8 100644 --- a/sdk/python/pulumi_spacelift/outputs.py +++ b/sdk/python/pulumi_spacelift/outputs.py @@ -6,10 +6,12 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities +from . import outputs __all__ = [ + 'IdpGroupMappingPolicy', 'ModuleAzureDevops', 'ModuleBitbucketCloud', 'ModuleBitbucketDatacenter', @@ -24,13 +26,21 @@ 'StackGitlab', 'StackKubernetes', 'StackPulumi', + 'StackRawGit', 'StackShowcase', + 'StackTerragrunt', + 'UserPolicy', + 'GetAwsIntegrationsIntegrationResult', + 'GetAzureIntegrationsIntegrationResult', + 'GetContextsContextResult', + 'GetContextsLabelResult', 'GetModuleAzureDevopResult', 'GetModuleBitbucketCloudResult', 'GetModuleBitbucketDatacenterResult', 'GetModuleGithubEnterpriseResult', 'GetModuleGitlabResult', 'GetPoliciesPolicyResult', + 'GetSpacesSpaceResult', 'GetStackAnsibleResult', 'GetStackAzureDevopResult', 'GetStackBitbucketCloudResult', @@ -40,11 +50,100 @@ 'GetStackGitlabResult', 'GetStackKuberneteResult', 'GetStackPulumiResult', + 'GetStackRawGitResult', 'GetStackShowcaseResult', + 'GetStacksAdministrativeResult', + 'GetStacksBranchResult', + 'GetStacksCommitResult', + 'GetStacksLabelResult', + 'GetStacksLockedResult', + 'GetStacksNameResult', + 'GetStacksProjectRootResult', + 'GetStacksRepositoryResult', + 'GetStacksStackResult', + 'GetStacksStackAnsibleResult', + 'GetStacksStackAzureDevopResult', + 'GetStacksStackBitbucketCloudResult', + 'GetStacksStackBitbucketDatacenterResult', + 'GetStacksStackCloudformationResult', + 'GetStacksStackGithubEnterpriseResult', + 'GetStacksStackGitlabResult', + 'GetStacksStackKuberneteResult', + 'GetStacksStackPulumiResult', + 'GetStacksStackRawGitResult', + 'GetStacksStackShowcaseResult', + 'GetStacksStateResult', + 'GetStacksVendorResult', + 'GetStacksWorkerPoolResult', 'GetVcsAgentPoolsVcsAgentPoolResult', 'GetWorkerPoolsWorkerPoolResult', ] +@pulumi.output_type +class IdpGroupMappingPolicy(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "spaceId": + suggest = "space_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in IdpGroupMappingPolicy. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + IdpGroupMappingPolicy.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + IdpGroupMappingPolicy.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + role: str, + space_id: str): + """ + :param str role: Type of access to the space. Possible values are: READ, WRITE, ADMIN + :param str space_id: ID (slug) of the space the user group has access to + """ + IdpGroupMappingPolicy._configure( + lambda key, value: pulumi.set(__self__, key, value), + role=role, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + role: Optional[str] = None, + space_id: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if role is None: + raise TypeError("Missing 'role' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + + _setter("role", role) + _setter("space_id", space_id) + + @property + @pulumi.getter + def role(self) -> str: + """ + Type of access to the space. Possible values are: READ, WRITE, ADMIN + """ + return pulumi.get(self, "role") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> str: + """ + ID (slug) of the space the user group has access to + """ + return pulumi.get(self, "space_id") + + @pulumi.output_type class ModuleAzureDevops(dict): def __init__(__self__, *, @@ -52,7 +151,20 @@ def __init__(__self__, *, """ :param str project: The name of the Azure DevOps project """ - pulumi.set(__self__, "project", project) + ModuleAzureDevops._configure( + lambda key, value: pulumi.set(__self__, key, value), + project=project, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + project: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if project is None: + raise TypeError("Missing 'project' argument") + + _setter("project", project) @property @pulumi.getter @@ -70,7 +182,20 @@ def __init__(__self__, *, """ :param str namespace: The Bitbucket project containing the repository """ - pulumi.set(__self__, "namespace", namespace) + ModuleBitbucketCloud._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -88,7 +213,20 @@ def __init__(__self__, *, """ :param str namespace: The Bitbucket project containing the repository """ - pulumi.set(__self__, "namespace", namespace) + ModuleBitbucketDatacenter._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -106,7 +244,20 @@ def __init__(__self__, *, """ :param str namespace: The GitHub organization / user the repository belongs to """ - pulumi.set(__self__, "namespace", namespace) + ModuleGithubEnterprise._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -124,7 +275,20 @@ def __init__(__self__, *, """ :param str namespace: The GitLab namespace containing the repository """ - pulumi.set(__self__, "namespace", namespace) + ModuleGitlab._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -142,7 +306,20 @@ def __init__(__self__, *, """ :param str playbook: The playbook Ansible should run. """ - pulumi.set(__self__, "playbook", playbook) + StackAnsible._configure( + lambda key, value: pulumi.set(__self__, key, value), + playbook=playbook, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + playbook: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if playbook is None: + raise TypeError("Missing 'playbook' argument") + + _setter("playbook", playbook) @property @pulumi.getter @@ -160,7 +337,20 @@ def __init__(__self__, *, """ :param str project: The name of the Azure DevOps project """ - pulumi.set(__self__, "project", project) + StackAzureDevops._configure( + lambda key, value: pulumi.set(__self__, key, value), + project=project, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + project: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if project is None: + raise TypeError("Missing 'project' argument") + + _setter("project", project) @property @pulumi.getter @@ -178,7 +368,20 @@ def __init__(__self__, *, """ :param str namespace: The Bitbucket project containing the repository """ - pulumi.set(__self__, "namespace", namespace) + StackBitbucketCloud._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -196,7 +399,20 @@ def __init__(__self__, *, """ :param str namespace: The Bitbucket project containing the repository """ - pulumi.set(__self__, "namespace", namespace) + StackBitbucketDatacenter._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -241,10 +457,41 @@ def __init__(__self__, *, :param str stack_name: CloudFormation stack name :param str template_bucket: S3 bucket to save CloudFormation templates to """ - pulumi.set(__self__, "entry_template_file", entry_template_file) - pulumi.set(__self__, "region", region) - pulumi.set(__self__, "stack_name", stack_name) - pulumi.set(__self__, "template_bucket", template_bucket) + StackCloudformation._configure( + lambda key, value: pulumi.set(__self__, key, value), + entry_template_file=entry_template_file, + region=region, + stack_name=stack_name, + template_bucket=template_bucket, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + entry_template_file: Optional[str] = None, + region: Optional[str] = None, + stack_name: Optional[str] = None, + template_bucket: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if entry_template_file is None and 'entryTemplateFile' in kwargs: + entry_template_file = kwargs['entryTemplateFile'] + if entry_template_file is None: + raise TypeError("Missing 'entry_template_file' argument") + if region is None: + raise TypeError("Missing 'region' argument") + if stack_name is None and 'stackName' in kwargs: + stack_name = kwargs['stackName'] + if stack_name is None: + raise TypeError("Missing 'stack_name' argument") + if template_bucket is None and 'templateBucket' in kwargs: + template_bucket = kwargs['templateBucket'] + if template_bucket is None: + raise TypeError("Missing 'template_bucket' argument") + + _setter("entry_template_file", entry_template_file) + _setter("region", region) + _setter("stack_name", stack_name) + _setter("template_bucket", template_bucket) @property @pulumi.getter(name="entryTemplateFile") @@ -286,7 +533,20 @@ def __init__(__self__, *, """ :param str namespace: The GitHub organization / user the repository belongs to """ - pulumi.set(__self__, "namespace", namespace) + StackGithubEnterprise._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -304,7 +564,20 @@ def __init__(__self__, *, """ :param str namespace: The GitLab namespace containing the repository """ - pulumi.set(__self__, "namespace", namespace) + StackGitlab._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -317,13 +590,57 @@ def namespace(self) -> str: @pulumi.output_type class StackKubernetes(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "kubectlVersion": + suggest = "kubectl_version" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StackKubernetes. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StackKubernetes.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StackKubernetes.__key_warning(key) + return super().get(key, default) + def __init__(__self__, *, + kubectl_version: Optional[str] = None, namespace: Optional[str] = None): """ + :param str kubectl_version: Kubectl version. :param str namespace: Namespace of the Kubernetes cluster to run commands on. Leave empty for multi-namespace Stacks. """ + StackKubernetes._configure( + lambda key, value: pulumi.set(__self__, key, value), + kubectl_version=kubectl_version, + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + kubectl_version: Optional[str] = None, + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if kubectl_version is None and 'kubectlVersion' in kwargs: + kubectl_version = kwargs['kubectlVersion'] + + if kubectl_version is not None: + _setter("kubectl_version", kubectl_version) if namespace is not None: - pulumi.set(__self__, "namespace", namespace) + _setter("namespace", namespace) + + @property + @pulumi.getter(name="kubectlVersion") + def kubectl_version(self) -> Optional[str]: + """ + Kubectl version. + """ + return pulumi.get(self, "kubectl_version") @property @pulumi.getter @@ -362,8 +679,29 @@ def __init__(__self__, *, :param str login_url: State backend to log into on Run initialize. :param str stack_name: Pulumi stack name to use with the state backend. """ - pulumi.set(__self__, "login_url", login_url) - pulumi.set(__self__, "stack_name", stack_name) + StackPulumi._configure( + lambda key, value: pulumi.set(__self__, key, value), + login_url=login_url, + stack_name=stack_name, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + login_url: Optional[str] = None, + stack_name: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if login_url is None and 'loginUrl' in kwargs: + login_url = kwargs['loginUrl'] + if login_url is None: + raise TypeError("Missing 'login_url' argument") + if stack_name is None and 'stackName' in kwargs: + stack_name = kwargs['stackName'] + if stack_name is None: + raise TypeError("Missing 'stack_name' argument") + + _setter("login_url", login_url) + _setter("stack_name", stack_name) @property @pulumi.getter(name="loginUrl") @@ -383,34 +721,69 @@ def stack_name(self) -> str: @pulumi.output_type -class StackShowcase(dict): +class StackRawGit(dict): def __init__(__self__, *, - namespace: str): - pulumi.set(__self__, "namespace", namespace) + namespace: str, + url: str): + """ + :param str namespace: User-friendly namespace for the repository, this is for cosmetic purposes only + :param str url: HTTPS URL of the Git repository + """ + StackRawGit._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + url=url, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + url: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + if url is None: + raise TypeError("Missing 'url' argument") + + _setter("namespace", namespace) + _setter("url", url) @property @pulumi.getter def namespace(self) -> str: + """ + User-friendly namespace for the repository, this is for cosmetic purposes only + """ return pulumi.get(self, "namespace") - -@pulumi.output_type -class GetModuleAzureDevopResult(dict): - def __init__(__self__, *, - project: str): - pulumi.set(__self__, "project", project) - @property @pulumi.getter - def project(self) -> str: - return pulumi.get(self, "project") + def url(self) -> str: + """ + HTTPS URL of the Git repository + """ + return pulumi.get(self, "url") @pulumi.output_type -class GetModuleBitbucketCloudResult(dict): +class StackShowcase(dict): def __init__(__self__, *, namespace: str): - pulumi.set(__self__, "namespace", namespace) + StackShowcase._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -419,74 +792,401 @@ def namespace(self) -> str: @pulumi.output_type -class GetModuleBitbucketDatacenterResult(dict): +class StackTerragrunt(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "terraformVersion": + suggest = "terraform_version" + elif key == "terragruntVersion": + suggest = "terragrunt_version" + elif key == "useRunAll": + suggest = "use_run_all" + elif key == "useSmartSanitization": + suggest = "use_smart_sanitization" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in StackTerragrunt. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + StackTerragrunt.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + StackTerragrunt.__key_warning(key) + return super().get(key, default) + def __init__(__self__, *, - namespace: str): - pulumi.set(__self__, "namespace", namespace) + terraform_version: Optional[str] = None, + terragrunt_version: Optional[str] = None, + use_run_all: Optional[bool] = None, + use_smart_sanitization: Optional[bool] = None): + """ + :param str terragrunt_version: Terragrunt version. + :param bool use_run_all: Whether to use `terragrunt run-all` instead of `terragrunt`. + """ + StackTerragrunt._configure( + lambda key, value: pulumi.set(__self__, key, value), + terraform_version=terraform_version, + terragrunt_version=terragrunt_version, + use_run_all=use_run_all, + use_smart_sanitization=use_smart_sanitization, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + terraform_version: Optional[str] = None, + terragrunt_version: Optional[str] = None, + use_run_all: Optional[bool] = None, + use_smart_sanitization: Optional[bool] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if terraform_version is None and 'terraformVersion' in kwargs: + terraform_version = kwargs['terraformVersion'] + if terragrunt_version is None and 'terragruntVersion' in kwargs: + terragrunt_version = kwargs['terragruntVersion'] + if use_run_all is None and 'useRunAll' in kwargs: + use_run_all = kwargs['useRunAll'] + if use_smart_sanitization is None and 'useSmartSanitization' in kwargs: + use_smart_sanitization = kwargs['useSmartSanitization'] + + if terraform_version is not None: + _setter("terraform_version", terraform_version) + if terragrunt_version is not None: + _setter("terragrunt_version", terragrunt_version) + if use_run_all is not None: + _setter("use_run_all", use_run_all) + if use_smart_sanitization is not None: + _setter("use_smart_sanitization", use_smart_sanitization) @property - @pulumi.getter - def namespace(self) -> str: - return pulumi.get(self, "namespace") + @pulumi.getter(name="terraformVersion") + def terraform_version(self) -> Optional[str]: + return pulumi.get(self, "terraform_version") + + @property + @pulumi.getter(name="terragruntVersion") + def terragrunt_version(self) -> Optional[str]: + """ + Terragrunt version. + """ + return pulumi.get(self, "terragrunt_version") + + @property + @pulumi.getter(name="useRunAll") + def use_run_all(self) -> Optional[bool]: + """ + Whether to use `terragrunt run-all` instead of `terragrunt`. + """ + return pulumi.get(self, "use_run_all") + + @property + @pulumi.getter(name="useSmartSanitization") + def use_smart_sanitization(self) -> Optional[bool]: + return pulumi.get(self, "use_smart_sanitization") @pulumi.output_type -class GetModuleGithubEnterpriseResult(dict): +class UserPolicy(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "spaceId": + suggest = "space_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in UserPolicy. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + UserPolicy.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + UserPolicy.__key_warning(key) + return super().get(key, default) + def __init__(__self__, *, - namespace: str): - pulumi.set(__self__, "namespace", namespace) + role: str, + space_id: str): + """ + :param str role: Type of access to the space. Possible values are: READ, WRITE, ADMIN + :param str space_id: ID (slug) of the space the user has access to + """ + UserPolicy._configure( + lambda key, value: pulumi.set(__self__, key, value), + role=role, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + role: Optional[str] = None, + space_id: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if role is None: + raise TypeError("Missing 'role' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + + _setter("role", role) + _setter("space_id", space_id) @property @pulumi.getter - def namespace(self) -> str: - return pulumi.get(self, "namespace") + def role(self) -> str: + """ + Type of access to the space. Possible values are: READ, WRITE, ADMIN + """ + return pulumi.get(self, "role") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> str: + """ + ID (slug) of the space the user has access to + """ + return pulumi.get(self, "space_id") @pulumi.output_type -class GetModuleGitlabResult(dict): +class GetAwsIntegrationsIntegrationResult(dict): def __init__(__self__, *, - namespace: str): - pulumi.set(__self__, "namespace", namespace) + duration_seconds: int, + external_id: str, + generate_credentials_in_worker: bool, + integration_id: str, + labels: Sequence[str], + name: str, + role_arn: str, + space_id: str): + GetAwsIntegrationsIntegrationResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + duration_seconds=duration_seconds, + external_id=external_id, + generate_credentials_in_worker=generate_credentials_in_worker, + integration_id=integration_id, + labels=labels, + name=name, + role_arn=role_arn, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + duration_seconds: Optional[int] = None, + external_id: Optional[str] = None, + generate_credentials_in_worker: Optional[bool] = None, + integration_id: Optional[str] = None, + labels: Optional[Sequence[str]] = None, + name: Optional[str] = None, + role_arn: Optional[str] = None, + space_id: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if duration_seconds is None and 'durationSeconds' in kwargs: + duration_seconds = kwargs['durationSeconds'] + if duration_seconds is None: + raise TypeError("Missing 'duration_seconds' argument") + if external_id is None and 'externalId' in kwargs: + external_id = kwargs['externalId'] + if external_id is None: + raise TypeError("Missing 'external_id' argument") + if generate_credentials_in_worker is None and 'generateCredentialsInWorker' in kwargs: + generate_credentials_in_worker = kwargs['generateCredentialsInWorker'] + if generate_credentials_in_worker is None: + raise TypeError("Missing 'generate_credentials_in_worker' argument") + if integration_id is None and 'integrationId' in kwargs: + integration_id = kwargs['integrationId'] + if integration_id is None: + raise TypeError("Missing 'integration_id' argument") + if labels is None: + raise TypeError("Missing 'labels' argument") + if name is None: + raise TypeError("Missing 'name' argument") + if role_arn is None and 'roleArn' in kwargs: + role_arn = kwargs['roleArn'] + if role_arn is None: + raise TypeError("Missing 'role_arn' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + + _setter("duration_seconds", duration_seconds) + _setter("external_id", external_id) + _setter("generate_credentials_in_worker", generate_credentials_in_worker) + _setter("integration_id", integration_id) + _setter("labels", labels) + _setter("name", name) + _setter("role_arn", role_arn) + _setter("space_id", space_id) + + @property + @pulumi.getter(name="durationSeconds") + def duration_seconds(self) -> int: + return pulumi.get(self, "duration_seconds") + + @property + @pulumi.getter(name="externalId") + def external_id(self) -> str: + return pulumi.get(self, "external_id") + + @property + @pulumi.getter(name="generateCredentialsInWorker") + def generate_credentials_in_worker(self) -> bool: + return pulumi.get(self, "generate_credentials_in_worker") + + @property + @pulumi.getter(name="integrationId") + def integration_id(self) -> str: + return pulumi.get(self, "integration_id") @property @pulumi.getter - def namespace(self) -> str: - return pulumi.get(self, "namespace") + def labels(self) -> Sequence[str]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="roleArn") + def role_arn(self) -> str: + return pulumi.get(self, "role_arn") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> str: + return pulumi.get(self, "space_id") @pulumi.output_type -class GetPoliciesPolicyResult(dict): +class GetAzureIntegrationsIntegrationResult(dict): def __init__(__self__, *, - id: str, + admin_consent_provided: bool, + admin_consent_url: str, + application_id: str, + default_subscription_id: str, + display_name: str, + integration_id: str, labels: Sequence[str], name: str, space_id: str, - type: str): - """ - :param str id: The ID of this resource. - :param Sequence[str] labels: required labels to match - :param str type: required policy type - """ - pulumi.set(__self__, "id", id) - pulumi.set(__self__, "labels", labels) - pulumi.set(__self__, "name", name) - pulumi.set(__self__, "space_id", space_id) - pulumi.set(__self__, "type", type) + tenant_id: str): + GetAzureIntegrationsIntegrationResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + admin_consent_provided=admin_consent_provided, + admin_consent_url=admin_consent_url, + application_id=application_id, + default_subscription_id=default_subscription_id, + display_name=display_name, + integration_id=integration_id, + labels=labels, + name=name, + space_id=space_id, + tenant_id=tenant_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + admin_consent_provided: Optional[bool] = None, + admin_consent_url: Optional[str] = None, + application_id: Optional[str] = None, + default_subscription_id: Optional[str] = None, + display_name: Optional[str] = None, + integration_id: Optional[str] = None, + labels: Optional[Sequence[str]] = None, + name: Optional[str] = None, + space_id: Optional[str] = None, + tenant_id: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if admin_consent_provided is None and 'adminConsentProvided' in kwargs: + admin_consent_provided = kwargs['adminConsentProvided'] + if admin_consent_provided is None: + raise TypeError("Missing 'admin_consent_provided' argument") + if admin_consent_url is None and 'adminConsentUrl' in kwargs: + admin_consent_url = kwargs['adminConsentUrl'] + if admin_consent_url is None: + raise TypeError("Missing 'admin_consent_url' argument") + if application_id is None and 'applicationId' in kwargs: + application_id = kwargs['applicationId'] + if application_id is None: + raise TypeError("Missing 'application_id' argument") + if default_subscription_id is None and 'defaultSubscriptionId' in kwargs: + default_subscription_id = kwargs['defaultSubscriptionId'] + if default_subscription_id is None: + raise TypeError("Missing 'default_subscription_id' argument") + if display_name is None and 'displayName' in kwargs: + display_name = kwargs['displayName'] + if display_name is None: + raise TypeError("Missing 'display_name' argument") + if integration_id is None and 'integrationId' in kwargs: + integration_id = kwargs['integrationId'] + if integration_id is None: + raise TypeError("Missing 'integration_id' argument") + if labels is None: + raise TypeError("Missing 'labels' argument") + if name is None: + raise TypeError("Missing 'name' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + if tenant_id is None and 'tenantId' in kwargs: + tenant_id = kwargs['tenantId'] + if tenant_id is None: + raise TypeError("Missing 'tenant_id' argument") + + _setter("admin_consent_provided", admin_consent_provided) + _setter("admin_consent_url", admin_consent_url) + _setter("application_id", application_id) + _setter("default_subscription_id", default_subscription_id) + _setter("display_name", display_name) + _setter("integration_id", integration_id) + _setter("labels", labels) + _setter("name", name) + _setter("space_id", space_id) + _setter("tenant_id", tenant_id) @property - @pulumi.getter - def id(self) -> str: - """ - The ID of this resource. - """ - return pulumi.get(self, "id") + @pulumi.getter(name="adminConsentProvided") + def admin_consent_provided(self) -> bool: + return pulumi.get(self, "admin_consent_provided") + + @property + @pulumi.getter(name="adminConsentUrl") + def admin_consent_url(self) -> str: + return pulumi.get(self, "admin_consent_url") + + @property + @pulumi.getter(name="applicationId") + def application_id(self) -> str: + return pulumi.get(self, "application_id") + + @property + @pulumi.getter(name="defaultSubscriptionId") + def default_subscription_id(self) -> str: + return pulumi.get(self, "default_subscription_id") + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> str: + return pulumi.get(self, "display_name") + + @property + @pulumi.getter(name="integrationId") + def integration_id(self) -> str: + return pulumi.get(self, "integration_id") @property @pulumi.getter def labels(self) -> Sequence[str]: - """ - required labels to match - """ return pulumi.get(self, "labels") @property @@ -500,31 +1200,129 @@ def space_id(self) -> str: return pulumi.get(self, "space_id") @property - @pulumi.getter - def type(self) -> str: - """ - required policy type - """ - return pulumi.get(self, "type") + @pulumi.getter(name="tenantId") + def tenant_id(self) -> str: + return pulumi.get(self, "tenant_id") @pulumi.output_type -class GetStackAnsibleResult(dict): +class GetContextsContextResult(dict): def __init__(__self__, *, - playbook: str): - pulumi.set(__self__, "playbook", playbook) + context_id: str, + description: str, + labels: Sequence[str], + name: str, + space_id: str): + GetContextsContextResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + context_id=context_id, + description=description, + labels=labels, + name=name, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + context_id: Optional[str] = None, + description: Optional[str] = None, + labels: Optional[Sequence[str]] = None, + name: Optional[str] = None, + space_id: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if context_id is None and 'contextId' in kwargs: + context_id = kwargs['contextId'] + if context_id is None: + raise TypeError("Missing 'context_id' argument") + if description is None: + raise TypeError("Missing 'description' argument") + if labels is None: + raise TypeError("Missing 'labels' argument") + if name is None: + raise TypeError("Missing 'name' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + + _setter("context_id", context_id) + _setter("description", description) + _setter("labels", labels) + _setter("name", name) + _setter("space_id", space_id) + + @property + @pulumi.getter(name="contextId") + def context_id(self) -> str: + return pulumi.get(self, "context_id") @property @pulumi.getter - def playbook(self) -> str: - return pulumi.get(self, "playbook") + def description(self) -> str: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def labels(self) -> Sequence[str]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> str: + return pulumi.get(self, "space_id") @pulumi.output_type -class GetStackAzureDevopResult(dict): +class GetContextsLabelResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetContextsLabelResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetModuleAzureDevopResult(dict): def __init__(__self__, *, project: str): - pulumi.set(__self__, "project", project) + GetModuleAzureDevopResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + project=project, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + project: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if project is None: + raise TypeError("Missing 'project' argument") + + _setter("project", project) @property @pulumi.getter @@ -533,10 +1331,23 @@ def project(self) -> str: @pulumi.output_type -class GetStackBitbucketCloudResult(dict): +class GetModuleBitbucketCloudResult(dict): def __init__(__self__, *, namespace: str): - pulumi.set(__self__, "namespace", namespace) + GetModuleBitbucketCloudResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -545,10 +1356,23 @@ def namespace(self) -> str: @pulumi.output_type -class GetStackBitbucketDatacenterResult(dict): +class GetModuleBitbucketDatacenterResult(dict): def __init__(__self__, *, namespace: str): - pulumi.set(__self__, "namespace", namespace) + GetModuleBitbucketDatacenterResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -557,16 +1381,1474 @@ def namespace(self) -> str: @pulumi.output_type -class GetStackCloudformationResult(dict): +class GetModuleGithubEnterpriseResult(dict): def __init__(__self__, *, - entry_template_file: str, - region: str, + namespace: str): + GetModuleGithubEnterpriseResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetModuleGitlabResult(dict): + def __init__(__self__, *, + namespace: str): + GetModuleGitlabResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetPoliciesPolicyResult(dict): + def __init__(__self__, *, + id: str, + labels: Sequence[str], + name: str, + space_id: str, + type: str): + GetPoliciesPolicyResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + id=id, + labels=labels, + name=name, + space_id=space_id, + type=type, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + id: Optional[str] = None, + labels: Optional[Sequence[str]] = None, + name: Optional[str] = None, + space_id: Optional[str] = None, + type: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if id is None: + raise TypeError("Missing 'id' argument") + if labels is None: + raise TypeError("Missing 'labels' argument") + if name is None: + raise TypeError("Missing 'name' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + if type is None: + raise TypeError("Missing 'type' argument") + + _setter("id", id) + _setter("labels", labels) + _setter("name", name) + _setter("space_id", space_id) + _setter("type", type) + + @property + @pulumi.getter + def id(self) -> str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Sequence[str]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> str: + return pulumi.get(self, "space_id") + + @property + @pulumi.getter + def type(self) -> str: + return pulumi.get(self, "type") + + +@pulumi.output_type +class GetSpacesSpaceResult(dict): + def __init__(__self__, *, + description: str, + inherit_entities: bool, + labels: Sequence[str], + name: str, + parent_space_id: str, + space_id: str): + GetSpacesSpaceResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + inherit_entities=inherit_entities, + labels=labels, + name=name, + parent_space_id=parent_space_id, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[str] = None, + inherit_entities: Optional[bool] = None, + labels: Optional[Sequence[str]] = None, + name: Optional[str] = None, + parent_space_id: Optional[str] = None, + space_id: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if description is None: + raise TypeError("Missing 'description' argument") + if inherit_entities is None and 'inheritEntities' in kwargs: + inherit_entities = kwargs['inheritEntities'] + if inherit_entities is None: + raise TypeError("Missing 'inherit_entities' argument") + if labels is None: + raise TypeError("Missing 'labels' argument") + if name is None: + raise TypeError("Missing 'name' argument") + if parent_space_id is None and 'parentSpaceId' in kwargs: + parent_space_id = kwargs['parentSpaceId'] + if parent_space_id is None: + raise TypeError("Missing 'parent_space_id' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + + _setter("description", description) + _setter("inherit_entities", inherit_entities) + _setter("labels", labels) + _setter("name", name) + _setter("parent_space_id", parent_space_id) + _setter("space_id", space_id) + + @property + @pulumi.getter + def description(self) -> str: + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="inheritEntities") + def inherit_entities(self) -> bool: + return pulumi.get(self, "inherit_entities") + + @property + @pulumi.getter + def labels(self) -> Sequence[str]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="parentSpaceId") + def parent_space_id(self) -> str: + return pulumi.get(self, "parent_space_id") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> str: + return pulumi.get(self, "space_id") + + +@pulumi.output_type +class GetStackAnsibleResult(dict): + def __init__(__self__, *, + playbook: str): + GetStackAnsibleResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + playbook=playbook, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + playbook: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if playbook is None: + raise TypeError("Missing 'playbook' argument") + + _setter("playbook", playbook) + + @property + @pulumi.getter + def playbook(self) -> str: + return pulumi.get(self, "playbook") + + +@pulumi.output_type +class GetStackAzureDevopResult(dict): + def __init__(__self__, *, + project: str): + GetStackAzureDevopResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + project=project, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + project: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if project is None: + raise TypeError("Missing 'project' argument") + + _setter("project", project) + + @property + @pulumi.getter + def project(self) -> str: + return pulumi.get(self, "project") + + +@pulumi.output_type +class GetStackBitbucketCloudResult(dict): + def __init__(__self__, *, + namespace: str): + GetStackBitbucketCloudResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetStackBitbucketDatacenterResult(dict): + def __init__(__self__, *, + namespace: str): + GetStackBitbucketDatacenterResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetStackCloudformationResult(dict): + def __init__(__self__, *, + entry_template_file: str, + region: str, + stack_name: str, + template_bucket: str): + GetStackCloudformationResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + entry_template_file=entry_template_file, + region=region, + stack_name=stack_name, + template_bucket=template_bucket, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + entry_template_file: Optional[str] = None, + region: Optional[str] = None, + stack_name: Optional[str] = None, + template_bucket: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if entry_template_file is None and 'entryTemplateFile' in kwargs: + entry_template_file = kwargs['entryTemplateFile'] + if entry_template_file is None: + raise TypeError("Missing 'entry_template_file' argument") + if region is None: + raise TypeError("Missing 'region' argument") + if stack_name is None and 'stackName' in kwargs: + stack_name = kwargs['stackName'] + if stack_name is None: + raise TypeError("Missing 'stack_name' argument") + if template_bucket is None and 'templateBucket' in kwargs: + template_bucket = kwargs['templateBucket'] + if template_bucket is None: + raise TypeError("Missing 'template_bucket' argument") + + _setter("entry_template_file", entry_template_file) + _setter("region", region) + _setter("stack_name", stack_name) + _setter("template_bucket", template_bucket) + + @property + @pulumi.getter(name="entryTemplateFile") + def entry_template_file(self) -> str: + return pulumi.get(self, "entry_template_file") + + @property + @pulumi.getter + def region(self) -> str: + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="stackName") + def stack_name(self) -> str: + return pulumi.get(self, "stack_name") + + @property + @pulumi.getter(name="templateBucket") + def template_bucket(self) -> str: + return pulumi.get(self, "template_bucket") + + +@pulumi.output_type +class GetStackGithubEnterpriseResult(dict): + def __init__(__self__, *, + namespace: str): + GetStackGithubEnterpriseResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetStackGitlabResult(dict): + def __init__(__self__, *, + namespace: str): + GetStackGitlabResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetStackKuberneteResult(dict): + def __init__(__self__, *, + kubectl_version: str, + namespace: str): + GetStackKuberneteResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + kubectl_version=kubectl_version, + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + kubectl_version: Optional[str] = None, + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if kubectl_version is None and 'kubectlVersion' in kwargs: + kubectl_version = kwargs['kubectlVersion'] + if kubectl_version is None: + raise TypeError("Missing 'kubectl_version' argument") + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("kubectl_version", kubectl_version) + _setter("namespace", namespace) + + @property + @pulumi.getter(name="kubectlVersion") + def kubectl_version(self) -> str: + return pulumi.get(self, "kubectl_version") + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetStackPulumiResult(dict): + def __init__(__self__, *, + login_url: str, + stack_name: str): + GetStackPulumiResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + login_url=login_url, + stack_name=stack_name, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + login_url: Optional[str] = None, + stack_name: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if login_url is None and 'loginUrl' in kwargs: + login_url = kwargs['loginUrl'] + if login_url is None: + raise TypeError("Missing 'login_url' argument") + if stack_name is None and 'stackName' in kwargs: + stack_name = kwargs['stackName'] + if stack_name is None: + raise TypeError("Missing 'stack_name' argument") + + _setter("login_url", login_url) + _setter("stack_name", stack_name) + + @property + @pulumi.getter(name="loginUrl") + def login_url(self) -> str: + return pulumi.get(self, "login_url") + + @property + @pulumi.getter(name="stackName") + def stack_name(self) -> str: + return pulumi.get(self, "stack_name") + + +@pulumi.output_type +class GetStackRawGitResult(dict): + def __init__(__self__, *, + namespace: str, + url: str): + GetStackRawGitResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + url=url, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + url: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + if url is None: + raise TypeError("Missing 'url' argument") + + _setter("namespace", namespace) + _setter("url", url) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + @property + @pulumi.getter + def url(self) -> str: + return pulumi.get(self, "url") + + +@pulumi.output_type +class GetStackShowcaseResult(dict): + def __init__(__self__, *, + namespace: str): + GetStackShowcaseResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetStacksAdministrativeResult(dict): + def __init__(__self__, *, + equals: Optional[bool] = None): + GetStacksAdministrativeResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + equals=equals, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + equals: Optional[bool] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + + if equals is not None: + _setter("equals", equals) + + @property + @pulumi.getter + def equals(self) -> Optional[bool]: + return pulumi.get(self, "equals") + + +@pulumi.output_type +class GetStacksBranchResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksBranchResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetStacksCommitResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksCommitResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetStacksLabelResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksLabelResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetStacksLockedResult(dict): + def __init__(__self__, *, + equals: Optional[bool] = None): + GetStacksLockedResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + equals=equals, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + equals: Optional[bool] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + + if equals is not None: + _setter("equals", equals) + + @property + @pulumi.getter + def equals(self) -> Optional[bool]: + return pulumi.get(self, "equals") + + +@pulumi.output_type +class GetStacksNameResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksNameResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetStacksProjectRootResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksProjectRootResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetStacksRepositoryResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksRepositoryResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetStacksStackResult(dict): + def __init__(__self__, *, + administrative: bool, + after_applies: Sequence[str], + after_destroys: Sequence[str], + after_inits: Sequence[str], + after_performs: Sequence[str], + after_plans: Sequence[str], + ansibles: Sequence['outputs.GetStacksStackAnsibleResult'], + autodeploy: bool, + autoretry: bool, + aws_assume_role_policy_statement: str, + azure_devops: Sequence['outputs.GetStacksStackAzureDevopResult'], + before_applies: Sequence[str], + before_destroys: Sequence[str], + before_inits: Sequence[str], + before_performs: Sequence[str], + before_plans: Sequence[str], + bitbucket_clouds: Sequence['outputs.GetStacksStackBitbucketCloudResult'], + bitbucket_datacenters: Sequence['outputs.GetStacksStackBitbucketDatacenterResult'], + branch: str, + cloudformations: Sequence['outputs.GetStacksStackCloudformationResult'], + description: str, + enable_local_preview: bool, + github_enterprises: Sequence['outputs.GetStacksStackGithubEnterpriseResult'], + gitlabs: Sequence['outputs.GetStacksStackGitlabResult'], + kubernetes: Sequence['outputs.GetStacksStackKuberneteResult'], + labels: Sequence[str], + manage_state: bool, + name: str, + project_root: str, + protect_from_deletion: bool, + pulumis: Sequence['outputs.GetStacksStackPulumiResult'], + raw_gits: Sequence['outputs.GetStacksStackRawGitResult'], + repository: str, + runner_image: str, + showcases: Sequence['outputs.GetStacksStackShowcaseResult'], + space_id: str, + stack_id: str, + terraform_external_state_access: bool, + terraform_smart_sanitization: bool, + terraform_version: str, + terraform_workflow_tool: str, + terraform_workspace: str, + worker_pool_id: str, + after_runs: Optional[Sequence[str]] = None): + GetStacksStackResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + administrative=administrative, + after_applies=after_applies, + after_destroys=after_destroys, + after_inits=after_inits, + after_performs=after_performs, + after_plans=after_plans, + ansibles=ansibles, + autodeploy=autodeploy, + autoretry=autoretry, + aws_assume_role_policy_statement=aws_assume_role_policy_statement, + azure_devops=azure_devops, + before_applies=before_applies, + before_destroys=before_destroys, + before_inits=before_inits, + before_performs=before_performs, + before_plans=before_plans, + bitbucket_clouds=bitbucket_clouds, + bitbucket_datacenters=bitbucket_datacenters, + branch=branch, + cloudformations=cloudformations, + description=description, + enable_local_preview=enable_local_preview, + github_enterprises=github_enterprises, + gitlabs=gitlabs, + kubernetes=kubernetes, + labels=labels, + manage_state=manage_state, + name=name, + project_root=project_root, + protect_from_deletion=protect_from_deletion, + pulumis=pulumis, + raw_gits=raw_gits, + repository=repository, + runner_image=runner_image, + showcases=showcases, + space_id=space_id, + stack_id=stack_id, + terraform_external_state_access=terraform_external_state_access, + terraform_smart_sanitization=terraform_smart_sanitization, + terraform_version=terraform_version, + terraform_workflow_tool=terraform_workflow_tool, + terraform_workspace=terraform_workspace, + worker_pool_id=worker_pool_id, + after_runs=after_runs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + administrative: Optional[bool] = None, + after_applies: Optional[Sequence[str]] = None, + after_destroys: Optional[Sequence[str]] = None, + after_inits: Optional[Sequence[str]] = None, + after_performs: Optional[Sequence[str]] = None, + after_plans: Optional[Sequence[str]] = None, + ansibles: Optional[Sequence['outputs.GetStacksStackAnsibleResult']] = None, + autodeploy: Optional[bool] = None, + autoretry: Optional[bool] = None, + aws_assume_role_policy_statement: Optional[str] = None, + azure_devops: Optional[Sequence['outputs.GetStacksStackAzureDevopResult']] = None, + before_applies: Optional[Sequence[str]] = None, + before_destroys: Optional[Sequence[str]] = None, + before_inits: Optional[Sequence[str]] = None, + before_performs: Optional[Sequence[str]] = None, + before_plans: Optional[Sequence[str]] = None, + bitbucket_clouds: Optional[Sequence['outputs.GetStacksStackBitbucketCloudResult']] = None, + bitbucket_datacenters: Optional[Sequence['outputs.GetStacksStackBitbucketDatacenterResult']] = None, + branch: Optional[str] = None, + cloudformations: Optional[Sequence['outputs.GetStacksStackCloudformationResult']] = None, + description: Optional[str] = None, + enable_local_preview: Optional[bool] = None, + github_enterprises: Optional[Sequence['outputs.GetStacksStackGithubEnterpriseResult']] = None, + gitlabs: Optional[Sequence['outputs.GetStacksStackGitlabResult']] = None, + kubernetes: Optional[Sequence['outputs.GetStacksStackKuberneteResult']] = None, + labels: Optional[Sequence[str]] = None, + manage_state: Optional[bool] = None, + name: Optional[str] = None, + project_root: Optional[str] = None, + protect_from_deletion: Optional[bool] = None, + pulumis: Optional[Sequence['outputs.GetStacksStackPulumiResult']] = None, + raw_gits: Optional[Sequence['outputs.GetStacksStackRawGitResult']] = None, + repository: Optional[str] = None, + runner_image: Optional[str] = None, + showcases: Optional[Sequence['outputs.GetStacksStackShowcaseResult']] = None, + space_id: Optional[str] = None, + stack_id: Optional[str] = None, + terraform_external_state_access: Optional[bool] = None, + terraform_smart_sanitization: Optional[bool] = None, + terraform_version: Optional[str] = None, + terraform_workflow_tool: Optional[str] = None, + terraform_workspace: Optional[str] = None, + worker_pool_id: Optional[str] = None, + after_runs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if administrative is None: + raise TypeError("Missing 'administrative' argument") + if after_applies is None and 'afterApplies' in kwargs: + after_applies = kwargs['afterApplies'] + if after_applies is None: + raise TypeError("Missing 'after_applies' argument") + if after_destroys is None and 'afterDestroys' in kwargs: + after_destroys = kwargs['afterDestroys'] + if after_destroys is None: + raise TypeError("Missing 'after_destroys' argument") + if after_inits is None and 'afterInits' in kwargs: + after_inits = kwargs['afterInits'] + if after_inits is None: + raise TypeError("Missing 'after_inits' argument") + if after_performs is None and 'afterPerforms' in kwargs: + after_performs = kwargs['afterPerforms'] + if after_performs is None: + raise TypeError("Missing 'after_performs' argument") + if after_plans is None and 'afterPlans' in kwargs: + after_plans = kwargs['afterPlans'] + if after_plans is None: + raise TypeError("Missing 'after_plans' argument") + if ansibles is None: + raise TypeError("Missing 'ansibles' argument") + if autodeploy is None: + raise TypeError("Missing 'autodeploy' argument") + if autoretry is None: + raise TypeError("Missing 'autoretry' argument") + if aws_assume_role_policy_statement is None and 'awsAssumeRolePolicyStatement' in kwargs: + aws_assume_role_policy_statement = kwargs['awsAssumeRolePolicyStatement'] + if aws_assume_role_policy_statement is None: + raise TypeError("Missing 'aws_assume_role_policy_statement' argument") + if azure_devops is None and 'azureDevops' in kwargs: + azure_devops = kwargs['azureDevops'] + if azure_devops is None: + raise TypeError("Missing 'azure_devops' argument") + if before_applies is None and 'beforeApplies' in kwargs: + before_applies = kwargs['beforeApplies'] + if before_applies is None: + raise TypeError("Missing 'before_applies' argument") + if before_destroys is None and 'beforeDestroys' in kwargs: + before_destroys = kwargs['beforeDestroys'] + if before_destroys is None: + raise TypeError("Missing 'before_destroys' argument") + if before_inits is None and 'beforeInits' in kwargs: + before_inits = kwargs['beforeInits'] + if before_inits is None: + raise TypeError("Missing 'before_inits' argument") + if before_performs is None and 'beforePerforms' in kwargs: + before_performs = kwargs['beforePerforms'] + if before_performs is None: + raise TypeError("Missing 'before_performs' argument") + if before_plans is None and 'beforePlans' in kwargs: + before_plans = kwargs['beforePlans'] + if before_plans is None: + raise TypeError("Missing 'before_plans' argument") + if bitbucket_clouds is None and 'bitbucketClouds' in kwargs: + bitbucket_clouds = kwargs['bitbucketClouds'] + if bitbucket_clouds is None: + raise TypeError("Missing 'bitbucket_clouds' argument") + if bitbucket_datacenters is None and 'bitbucketDatacenters' in kwargs: + bitbucket_datacenters = kwargs['bitbucketDatacenters'] + if bitbucket_datacenters is None: + raise TypeError("Missing 'bitbucket_datacenters' argument") + if branch is None: + raise TypeError("Missing 'branch' argument") + if cloudformations is None: + raise TypeError("Missing 'cloudformations' argument") + if description is None: + raise TypeError("Missing 'description' argument") + if enable_local_preview is None and 'enableLocalPreview' in kwargs: + enable_local_preview = kwargs['enableLocalPreview'] + if enable_local_preview is None: + raise TypeError("Missing 'enable_local_preview' argument") + if github_enterprises is None and 'githubEnterprises' in kwargs: + github_enterprises = kwargs['githubEnterprises'] + if github_enterprises is None: + raise TypeError("Missing 'github_enterprises' argument") + if gitlabs is None: + raise TypeError("Missing 'gitlabs' argument") + if kubernetes is None: + raise TypeError("Missing 'kubernetes' argument") + if labels is None: + raise TypeError("Missing 'labels' argument") + if manage_state is None and 'manageState' in kwargs: + manage_state = kwargs['manageState'] + if manage_state is None: + raise TypeError("Missing 'manage_state' argument") + if name is None: + raise TypeError("Missing 'name' argument") + if project_root is None and 'projectRoot' in kwargs: + project_root = kwargs['projectRoot'] + if project_root is None: + raise TypeError("Missing 'project_root' argument") + if protect_from_deletion is None and 'protectFromDeletion' in kwargs: + protect_from_deletion = kwargs['protectFromDeletion'] + if protect_from_deletion is None: + raise TypeError("Missing 'protect_from_deletion' argument") + if pulumis is None: + raise TypeError("Missing 'pulumis' argument") + if raw_gits is None and 'rawGits' in kwargs: + raw_gits = kwargs['rawGits'] + if raw_gits is None: + raise TypeError("Missing 'raw_gits' argument") + if repository is None: + raise TypeError("Missing 'repository' argument") + if runner_image is None and 'runnerImage' in kwargs: + runner_image = kwargs['runnerImage'] + if runner_image is None: + raise TypeError("Missing 'runner_image' argument") + if showcases is None: + raise TypeError("Missing 'showcases' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if stack_id is None: + raise TypeError("Missing 'stack_id' argument") + if terraform_external_state_access is None and 'terraformExternalStateAccess' in kwargs: + terraform_external_state_access = kwargs['terraformExternalStateAccess'] + if terraform_external_state_access is None: + raise TypeError("Missing 'terraform_external_state_access' argument") + if terraform_smart_sanitization is None and 'terraformSmartSanitization' in kwargs: + terraform_smart_sanitization = kwargs['terraformSmartSanitization'] + if terraform_smart_sanitization is None: + raise TypeError("Missing 'terraform_smart_sanitization' argument") + if terraform_version is None and 'terraformVersion' in kwargs: + terraform_version = kwargs['terraformVersion'] + if terraform_version is None: + raise TypeError("Missing 'terraform_version' argument") + if terraform_workflow_tool is None and 'terraformWorkflowTool' in kwargs: + terraform_workflow_tool = kwargs['terraformWorkflowTool'] + if terraform_workflow_tool is None: + raise TypeError("Missing 'terraform_workflow_tool' argument") + if terraform_workspace is None and 'terraformWorkspace' in kwargs: + terraform_workspace = kwargs['terraformWorkspace'] + if terraform_workspace is None: + raise TypeError("Missing 'terraform_workspace' argument") + if worker_pool_id is None and 'workerPoolId' in kwargs: + worker_pool_id = kwargs['workerPoolId'] + if worker_pool_id is None: + raise TypeError("Missing 'worker_pool_id' argument") + if after_runs is None and 'afterRuns' in kwargs: + after_runs = kwargs['afterRuns'] + + _setter("administrative", administrative) + _setter("after_applies", after_applies) + _setter("after_destroys", after_destroys) + _setter("after_inits", after_inits) + _setter("after_performs", after_performs) + _setter("after_plans", after_plans) + _setter("ansibles", ansibles) + _setter("autodeploy", autodeploy) + _setter("autoretry", autoretry) + _setter("aws_assume_role_policy_statement", aws_assume_role_policy_statement) + _setter("azure_devops", azure_devops) + _setter("before_applies", before_applies) + _setter("before_destroys", before_destroys) + _setter("before_inits", before_inits) + _setter("before_performs", before_performs) + _setter("before_plans", before_plans) + _setter("bitbucket_clouds", bitbucket_clouds) + _setter("bitbucket_datacenters", bitbucket_datacenters) + _setter("branch", branch) + _setter("cloudformations", cloudformations) + _setter("description", description) + _setter("enable_local_preview", enable_local_preview) + _setter("github_enterprises", github_enterprises) + _setter("gitlabs", gitlabs) + _setter("kubernetes", kubernetes) + _setter("labels", labels) + _setter("manage_state", manage_state) + _setter("name", name) + _setter("project_root", project_root) + _setter("protect_from_deletion", protect_from_deletion) + _setter("pulumis", pulumis) + _setter("raw_gits", raw_gits) + _setter("repository", repository) + _setter("runner_image", runner_image) + _setter("showcases", showcases) + _setter("space_id", space_id) + _setter("stack_id", stack_id) + _setter("terraform_external_state_access", terraform_external_state_access) + _setter("terraform_smart_sanitization", terraform_smart_sanitization) + _setter("terraform_version", terraform_version) + _setter("terraform_workflow_tool", terraform_workflow_tool) + _setter("terraform_workspace", terraform_workspace) + _setter("worker_pool_id", worker_pool_id) + if after_runs is not None: + _setter("after_runs", after_runs) + + @property + @pulumi.getter + def administrative(self) -> bool: + return pulumi.get(self, "administrative") + + @property + @pulumi.getter(name="afterApplies") + def after_applies(self) -> Sequence[str]: + return pulumi.get(self, "after_applies") + + @property + @pulumi.getter(name="afterDestroys") + def after_destroys(self) -> Sequence[str]: + return pulumi.get(self, "after_destroys") + + @property + @pulumi.getter(name="afterInits") + def after_inits(self) -> Sequence[str]: + return pulumi.get(self, "after_inits") + + @property + @pulumi.getter(name="afterPerforms") + def after_performs(self) -> Sequence[str]: + return pulumi.get(self, "after_performs") + + @property + @pulumi.getter(name="afterPlans") + def after_plans(self) -> Sequence[str]: + return pulumi.get(self, "after_plans") + + @property + @pulumi.getter + def ansibles(self) -> Sequence['outputs.GetStacksStackAnsibleResult']: + return pulumi.get(self, "ansibles") + + @property + @pulumi.getter + def autodeploy(self) -> bool: + return pulumi.get(self, "autodeploy") + + @property + @pulumi.getter + def autoretry(self) -> bool: + return pulumi.get(self, "autoretry") + + @property + @pulumi.getter(name="awsAssumeRolePolicyStatement") + def aws_assume_role_policy_statement(self) -> str: + return pulumi.get(self, "aws_assume_role_policy_statement") + + @property + @pulumi.getter(name="azureDevops") + def azure_devops(self) -> Sequence['outputs.GetStacksStackAzureDevopResult']: + return pulumi.get(self, "azure_devops") + + @property + @pulumi.getter(name="beforeApplies") + def before_applies(self) -> Sequence[str]: + return pulumi.get(self, "before_applies") + + @property + @pulumi.getter(name="beforeDestroys") + def before_destroys(self) -> Sequence[str]: + return pulumi.get(self, "before_destroys") + + @property + @pulumi.getter(name="beforeInits") + def before_inits(self) -> Sequence[str]: + return pulumi.get(self, "before_inits") + + @property + @pulumi.getter(name="beforePerforms") + def before_performs(self) -> Sequence[str]: + return pulumi.get(self, "before_performs") + + @property + @pulumi.getter(name="beforePlans") + def before_plans(self) -> Sequence[str]: + return pulumi.get(self, "before_plans") + + @property + @pulumi.getter(name="bitbucketClouds") + def bitbucket_clouds(self) -> Sequence['outputs.GetStacksStackBitbucketCloudResult']: + return pulumi.get(self, "bitbucket_clouds") + + @property + @pulumi.getter(name="bitbucketDatacenters") + def bitbucket_datacenters(self) -> Sequence['outputs.GetStacksStackBitbucketDatacenterResult']: + return pulumi.get(self, "bitbucket_datacenters") + + @property + @pulumi.getter + def branch(self) -> str: + return pulumi.get(self, "branch") + + @property + @pulumi.getter + def cloudformations(self) -> Sequence['outputs.GetStacksStackCloudformationResult']: + return pulumi.get(self, "cloudformations") + + @property + @pulumi.getter + def description(self) -> str: + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="enableLocalPreview") + def enable_local_preview(self) -> bool: + return pulumi.get(self, "enable_local_preview") + + @property + @pulumi.getter(name="githubEnterprises") + def github_enterprises(self) -> Sequence['outputs.GetStacksStackGithubEnterpriseResult']: + return pulumi.get(self, "github_enterprises") + + @property + @pulumi.getter + def gitlabs(self) -> Sequence['outputs.GetStacksStackGitlabResult']: + return pulumi.get(self, "gitlabs") + + @property + @pulumi.getter + def kubernetes(self) -> Sequence['outputs.GetStacksStackKuberneteResult']: + return pulumi.get(self, "kubernetes") + + @property + @pulumi.getter + def labels(self) -> Sequence[str]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="manageState") + def manage_state(self) -> bool: + return pulumi.get(self, "manage_state") + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectRoot") + def project_root(self) -> str: + return pulumi.get(self, "project_root") + + @property + @pulumi.getter(name="protectFromDeletion") + def protect_from_deletion(self) -> bool: + return pulumi.get(self, "protect_from_deletion") + + @property + @pulumi.getter + def pulumis(self) -> Sequence['outputs.GetStacksStackPulumiResult']: + return pulumi.get(self, "pulumis") + + @property + @pulumi.getter(name="rawGits") + def raw_gits(self) -> Sequence['outputs.GetStacksStackRawGitResult']: + return pulumi.get(self, "raw_gits") + + @property + @pulumi.getter + def repository(self) -> str: + return pulumi.get(self, "repository") + + @property + @pulumi.getter(name="runnerImage") + def runner_image(self) -> str: + return pulumi.get(self, "runner_image") + + @property + @pulumi.getter + def showcases(self) -> Sequence['outputs.GetStacksStackShowcaseResult']: + return pulumi.get(self, "showcases") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> str: + return pulumi.get(self, "space_id") + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> str: + return pulumi.get(self, "stack_id") + + @property + @pulumi.getter(name="terraformExternalStateAccess") + def terraform_external_state_access(self) -> bool: + return pulumi.get(self, "terraform_external_state_access") + + @property + @pulumi.getter(name="terraformSmartSanitization") + def terraform_smart_sanitization(self) -> bool: + return pulumi.get(self, "terraform_smart_sanitization") + + @property + @pulumi.getter(name="terraformVersion") + def terraform_version(self) -> str: + return pulumi.get(self, "terraform_version") + + @property + @pulumi.getter(name="terraformWorkflowTool") + def terraform_workflow_tool(self) -> str: + return pulumi.get(self, "terraform_workflow_tool") + + @property + @pulumi.getter(name="terraformWorkspace") + def terraform_workspace(self) -> str: + return pulumi.get(self, "terraform_workspace") + + @property + @pulumi.getter(name="workerPoolId") + def worker_pool_id(self) -> str: + return pulumi.get(self, "worker_pool_id") + + @property + @pulumi.getter(name="afterRuns") + def after_runs(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "after_runs") + + +@pulumi.output_type +class GetStacksStackAnsibleResult(dict): + def __init__(__self__, *, + playbook: str): + GetStacksStackAnsibleResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + playbook=playbook, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + playbook: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if playbook is None: + raise TypeError("Missing 'playbook' argument") + + _setter("playbook", playbook) + + @property + @pulumi.getter + def playbook(self) -> str: + return pulumi.get(self, "playbook") + + +@pulumi.output_type +class GetStacksStackAzureDevopResult(dict): + def __init__(__self__, *, + project: str): + GetStacksStackAzureDevopResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + project=project, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + project: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if project is None: + raise TypeError("Missing 'project' argument") + + _setter("project", project) + + @property + @pulumi.getter + def project(self) -> str: + return pulumi.get(self, "project") + + +@pulumi.output_type +class GetStacksStackBitbucketCloudResult(dict): + def __init__(__self__, *, + namespace: str): + GetStacksStackBitbucketCloudResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetStacksStackBitbucketDatacenterResult(dict): + def __init__(__self__, *, + namespace: str): + GetStacksStackBitbucketDatacenterResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + +@pulumi.output_type +class GetStacksStackCloudformationResult(dict): + def __init__(__self__, *, + entry_template_file: str, + region: str, stack_name: str, template_bucket: str): - pulumi.set(__self__, "entry_template_file", entry_template_file) - pulumi.set(__self__, "region", region) - pulumi.set(__self__, "stack_name", stack_name) - pulumi.set(__self__, "template_bucket", template_bucket) + GetStacksStackCloudformationResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + entry_template_file=entry_template_file, + region=region, + stack_name=stack_name, + template_bucket=template_bucket, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + entry_template_file: Optional[str] = None, + region: Optional[str] = None, + stack_name: Optional[str] = None, + template_bucket: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if entry_template_file is None and 'entryTemplateFile' in kwargs: + entry_template_file = kwargs['entryTemplateFile'] + if entry_template_file is None: + raise TypeError("Missing 'entry_template_file' argument") + if region is None: + raise TypeError("Missing 'region' argument") + if stack_name is None and 'stackName' in kwargs: + stack_name = kwargs['stackName'] + if stack_name is None: + raise TypeError("Missing 'stack_name' argument") + if template_bucket is None and 'templateBucket' in kwargs: + template_bucket = kwargs['templateBucket'] + if template_bucket is None: + raise TypeError("Missing 'template_bucket' argument") + + _setter("entry_template_file", entry_template_file) + _setter("region", region) + _setter("stack_name", stack_name) + _setter("template_bucket", template_bucket) @property @pulumi.getter(name="entryTemplateFile") @@ -590,10 +2872,23 @@ def template_bucket(self) -> str: @pulumi.output_type -class GetStackGithubEnterpriseResult(dict): +class GetStacksStackGithubEnterpriseResult(dict): def __init__(__self__, *, namespace: str): - pulumi.set(__self__, "namespace", namespace) + GetStacksStackGithubEnterpriseResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -602,10 +2897,23 @@ def namespace(self) -> str: @pulumi.output_type -class GetStackGitlabResult(dict): +class GetStacksStackGitlabResult(dict): def __init__(__self__, *, namespace: str): - pulumi.set(__self__, "namespace", namespace) + GetStacksStackGitlabResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -614,10 +2922,36 @@ def namespace(self) -> str: @pulumi.output_type -class GetStackKuberneteResult(dict): +class GetStacksStackKuberneteResult(dict): def __init__(__self__, *, + kubectl_version: str, namespace: str): - pulumi.set(__self__, "namespace", namespace) + GetStacksStackKuberneteResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + kubectl_version=kubectl_version, + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + kubectl_version: Optional[str] = None, + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if kubectl_version is None and 'kubectlVersion' in kwargs: + kubectl_version = kwargs['kubectlVersion'] + if kubectl_version is None: + raise TypeError("Missing 'kubectl_version' argument") + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("kubectl_version", kubectl_version) + _setter("namespace", namespace) + + @property + @pulumi.getter(name="kubectlVersion") + def kubectl_version(self) -> str: + return pulumi.get(self, "kubectl_version") @property @pulumi.getter @@ -626,12 +2960,33 @@ def namespace(self) -> str: @pulumi.output_type -class GetStackPulumiResult(dict): +class GetStacksStackPulumiResult(dict): def __init__(__self__, *, login_url: str, stack_name: str): - pulumi.set(__self__, "login_url", login_url) - pulumi.set(__self__, "stack_name", stack_name) + GetStacksStackPulumiResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + login_url=login_url, + stack_name=stack_name, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + login_url: Optional[str] = None, + stack_name: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if login_url is None and 'loginUrl' in kwargs: + login_url = kwargs['loginUrl'] + if login_url is None: + raise TypeError("Missing 'login_url' argument") + if stack_name is None and 'stackName' in kwargs: + stack_name = kwargs['stackName'] + if stack_name is None: + raise TypeError("Missing 'stack_name' argument") + + _setter("login_url", login_url) + _setter("stack_name", stack_name) @property @pulumi.getter(name="loginUrl") @@ -645,10 +3000,59 @@ def stack_name(self) -> str: @pulumi.output_type -class GetStackShowcaseResult(dict): +class GetStacksStackRawGitResult(dict): + def __init__(__self__, *, + namespace: str, + url: str): + GetStacksStackRawGitResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + url=url, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + url: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + if url is None: + raise TypeError("Missing 'url' argument") + + _setter("namespace", namespace) + _setter("url", url) + + @property + @pulumi.getter + def namespace(self) -> str: + return pulumi.get(self, "namespace") + + @property + @pulumi.getter + def url(self) -> str: + return pulumi.get(self, "url") + + +@pulumi.output_type +class GetStacksStackShowcaseResult(dict): def __init__(__self__, *, namespace: str): - pulumi.set(__self__, "namespace", namespace) + GetStacksStackShowcaseResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + namespace=namespace, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + namespace: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if namespace is None: + raise TypeError("Missing 'namespace' argument") + + _setter("namespace", namespace) @property @pulumi.getter @@ -656,15 +3060,119 @@ def namespace(self) -> str: return pulumi.get(self, "namespace") +@pulumi.output_type +class GetStacksStateResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksStateResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetStacksVendorResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksVendorResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + +@pulumi.output_type +class GetStacksWorkerPoolResult(dict): + def __init__(__self__, *, + any_ofs: Sequence[str]): + GetStacksWorkerPoolResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + any_ofs=any_ofs, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + any_ofs: Optional[Sequence[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if any_ofs is None and 'anyOfs' in kwargs: + any_ofs = kwargs['anyOfs'] + if any_ofs is None: + raise TypeError("Missing 'any_ofs' argument") + + _setter("any_ofs", any_ofs) + + @property + @pulumi.getter(name="anyOfs") + def any_ofs(self) -> Sequence[str]: + return pulumi.get(self, "any_ofs") + + @pulumi.output_type class GetVcsAgentPoolsVcsAgentPoolResult(dict): def __init__(__self__, *, description: str, name: str, vcs_agent_pool_id: str): - pulumi.set(__self__, "description", description) - pulumi.set(__self__, "name", name) - pulumi.set(__self__, "vcs_agent_pool_id", vcs_agent_pool_id) + GetVcsAgentPoolsVcsAgentPoolResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + name=name, + vcs_agent_pool_id=vcs_agent_pool_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[str] = None, + name: Optional[str] = None, + vcs_agent_pool_id: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if description is None: + raise TypeError("Missing 'description' argument") + if name is None: + raise TypeError("Missing 'name' argument") + if vcs_agent_pool_id is None and 'vcsAgentPoolId' in kwargs: + vcs_agent_pool_id = kwargs['vcsAgentPoolId'] + if vcs_agent_pool_id is None: + raise TypeError("Missing 'vcs_agent_pool_id' argument") + + _setter("description", description) + _setter("name", name) + _setter("vcs_agent_pool_id", vcs_agent_pool_id) @property @pulumi.getter @@ -690,11 +3198,44 @@ def __init__(__self__, *, name: str, space_id: str, worker_pool_id: str): - pulumi.set(__self__, "config", config) - pulumi.set(__self__, "description", description) - pulumi.set(__self__, "name", name) - pulumi.set(__self__, "space_id", space_id) - pulumi.set(__self__, "worker_pool_id", worker_pool_id) + GetWorkerPoolsWorkerPoolResult._configure( + lambda key, value: pulumi.set(__self__, key, value), + config=config, + description=description, + name=name, + space_id=space_id, + worker_pool_id=worker_pool_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + config: Optional[str] = None, + description: Optional[str] = None, + name: Optional[str] = None, + space_id: Optional[str] = None, + worker_pool_id: Optional[str] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if config is None: + raise TypeError("Missing 'config' argument") + if description is None: + raise TypeError("Missing 'description' argument") + if name is None: + raise TypeError("Missing 'name' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + if worker_pool_id is None and 'workerPoolId' in kwargs: + worker_pool_id = kwargs['workerPoolId'] + if worker_pool_id is None: + raise TypeError("Missing 'worker_pool_id' argument") + + _setter("config", config) + _setter("description", description) + _setter("name", name) + _setter("space_id", space_id) + _setter("worker_pool_id", worker_pool_id) @property @pulumi.getter diff --git a/sdk/python/pulumi_spacelift/policy.py b/sdk/python/pulumi_spacelift/policy.py index 0554d1c..d85cc07 100644 --- a/sdk/python/pulumi_spacelift/policy.py +++ b/sdk/python/pulumi_spacelift/policy.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['PolicyArgs', 'Policy'] @@ -22,18 +22,43 @@ def __init__(__self__, *, """ The set of arguments for constructing a Policy resource. :param pulumi.Input[str] body: Body of the policy - :param pulumi.Input[str] type: Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + :param pulumi.Input[str] type: Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). :param pulumi.Input[str] name: Name of the policy - should be unique in one account :param pulumi.Input[str] space_id: ID (slug) of the space the policy is in """ - pulumi.set(__self__, "body", body) - pulumi.set(__self__, "type", type) + PolicyArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + body=body, + type=type, + labels=labels, + name=name, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + body: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if body is None: + raise TypeError("Missing 'body' argument") + if type is None: + raise TypeError("Missing 'type' argument") + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + + _setter("body", body) + _setter("type", type) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) @property @pulumi.getter @@ -51,7 +76,7 @@ def body(self, value: pulumi.Input[str]): @pulumi.getter def type(self) -> pulumi.Input[str]: """ - Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). """ return pulumi.get(self, "type") @@ -106,18 +131,39 @@ def __init__(__self__, *, :param pulumi.Input[str] body: Body of the policy :param pulumi.Input[str] name: Name of the policy - should be unique in one account :param pulumi.Input[str] space_id: ID (slug) of the space the policy is in - :param pulumi.Input[str] type: Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). - """ + :param pulumi.Input[str] type: Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + """ + _PolicyState._configure( + lambda key, value: pulumi.set(__self__, key, value), + body=body, + labels=labels, + name=name, + space_id=space_id, + type=type, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + body: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if body is not None: - pulumi.set(__self__, "body", body) + _setter("body", body) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) if type is not None: - pulumi.set(__self__, "type", type) + _setter("type", type) @property @pulumi.getter @@ -168,7 +214,7 @@ def space_id(self, value: Optional[pulumi.Input[str]]): @pulumi.getter def type(self) -> Optional[pulumi.Input[str]]: """ - Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). """ return pulumi.get(self, "type") @@ -219,7 +265,7 @@ def __init__(__self__, :param pulumi.Input[str] body: Body of the policy :param pulumi.Input[str] name: Name of the policy - should be unique in one account :param pulumi.Input[str] space_id: ID (slug) of the space the policy is in - :param pulumi.Input[str] type: Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + :param pulumi.Input[str] type: Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). """ ... @overload @@ -263,6 +309,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + PolicyArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -316,7 +366,7 @@ def get(resource_name: str, :param pulumi.Input[str] body: Body of the policy :param pulumi.Input[str] name: Name of the policy - should be unique in one account :param pulumi.Input[str] space_id: ID (slug) of the space the policy is in - :param pulumi.Input[str] type: Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + :param pulumi.Input[str] type: Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). """ opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) @@ -362,7 +412,7 @@ def space_id(self) -> pulumi.Output[str]: @pulumi.getter def type(self) -> pulumi.Output[str]: """ - Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, and `TRIGGER`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). + Type of the policy. Possible values are `ACCESS`, `APPROVAL`, `GIT_PUSH`, `INITIALIZATION`, `LOGIN`, `PLAN`, `TASK`, `TRIGGER` and `NOTIFICATION`. Deprecated values are `STACK_ACCESS` (use `ACCESS` instead), `TASK_RUN` (use `TASK` instead), and `TERRAFORM_PLAN` (use `PLAN` instead). """ return pulumi.get(self, "type") diff --git a/sdk/python/pulumi_spacelift/policy_attachment.py b/sdk/python/pulumi_spacelift/policy_attachment.py index cd10c17..9795d37 100644 --- a/sdk/python/pulumi_spacelift/policy_attachment.py +++ b/sdk/python/pulumi_spacelift/policy_attachment.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['PolicyAttachmentArgs', 'PolicyAttachment'] @@ -23,11 +23,34 @@ def __init__(__self__, *, :param pulumi.Input[str] module_id: ID of the module to attach the policy to :param pulumi.Input[str] stack_id: ID of the stack to attach the policy to """ - pulumi.set(__self__, "policy_id", policy_id) + PolicyAttachmentArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + policy_id=policy_id, + module_id=module_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + policy_id: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if policy_id is None and 'policyId' in kwargs: + policy_id = kwargs['policyId'] + if policy_id is None: + raise TypeError("Missing 'policy_id' argument") + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + _setter("policy_id", policy_id) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="policyId") @@ -78,12 +101,33 @@ def __init__(__self__, *, :param pulumi.Input[str] policy_id: ID of the policy to attach :param pulumi.Input[str] stack_id: ID of the stack to attach the policy to """ + _PolicyAttachmentState._configure( + lambda key, value: pulumi.set(__self__, key, value), + module_id=module_id, + policy_id=policy_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + module_id: Optional[pulumi.Input[str]] = None, + policy_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if policy_id is None and 'policyId' in kwargs: + policy_id = kwargs['policyId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if policy_id is not None: - pulumi.set(__self__, "policy_id", policy_id) + _setter("policy_id", policy_id) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="moduleId") @@ -205,6 +249,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + PolicyAttachmentArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/provider.py b/sdk/python/pulumi_spacelift/provider.py index 8978654..7444552 100644 --- a/sdk/python/pulumi_spacelift/provider.py +++ b/sdk/python/pulumi_spacelift/provider.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['ProviderArgs', 'Provider'] @@ -25,22 +25,47 @@ def __init__(__self__, *, :param pulumi.Input[str] api_key_secret: API key secret to use when executing outside of Spacelift :param pulumi.Input[str] api_token: Spacelift token generated by a run, only useful from within Spacelift """ + ProviderArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + api_key_endpoint=api_key_endpoint, + api_key_id=api_key_id, + api_key_secret=api_key_secret, + api_token=api_token, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + api_key_endpoint: Optional[pulumi.Input[str]] = None, + api_key_id: Optional[pulumi.Input[str]] = None, + api_key_secret: Optional[pulumi.Input[str]] = None, + api_token: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if api_key_endpoint is None and 'apiKeyEndpoint' in kwargs: + api_key_endpoint = kwargs['apiKeyEndpoint'] + if api_key_id is None and 'apiKeyId' in kwargs: + api_key_id = kwargs['apiKeyId'] + if api_key_secret is None and 'apiKeySecret' in kwargs: + api_key_secret = kwargs['apiKeySecret'] + if api_token is None and 'apiToken' in kwargs: + api_token = kwargs['apiToken'] + if api_key_endpoint is None: api_key_endpoint = _utilities.get_env('SPACELIFT_API_KEY_ENDPOINT') if api_key_endpoint is not None: - pulumi.set(__self__, "api_key_endpoint", api_key_endpoint) + _setter("api_key_endpoint", api_key_endpoint) if api_key_id is None: api_key_id = _utilities.get_env('SPACELIFT_API_KEY_ID') if api_key_id is not None: - pulumi.set(__self__, "api_key_id", api_key_id) + _setter("api_key_id", api_key_id) if api_key_secret is None: api_key_secret = _utilities.get_env('SPACELIFT_API_KEY_SECRET') if api_key_secret is not None: - pulumi.set(__self__, "api_key_secret", api_key_secret) + _setter("api_key_secret", api_key_secret) if api_token is None: api_token = _utilities.get_env('SPACELIFT_API_TOKEN') if api_token is not None: - pulumi.set(__self__, "api_token", api_token) + _setter("api_token", api_token) @property @pulumi.getter(name="apiKeyEndpoint") @@ -136,6 +161,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + ProviderArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/run.py b/sdk/python/pulumi_spacelift/run.py index 2ecba5c..ae77856 100644 --- a/sdk/python/pulumi_spacelift/run.py +++ b/sdk/python/pulumi_spacelift/run.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['RunArgs', 'Run'] @@ -25,13 +25,36 @@ def __init__(__self__, *, :param pulumi.Input[Mapping[str, Any]] keepers: Arbitrary map of values that, when changed, will trigger recreation of the resource. :param pulumi.Input[bool] proposed: Whether the run is a proposed run. Defaults to `false`. """ - pulumi.set(__self__, "stack_id", stack_id) + RunArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + stack_id=stack_id, + commit_sha=commit_sha, + keepers=keepers, + proposed=proposed, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + stack_id: Optional[pulumi.Input[str]] = None, + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + proposed: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if stack_id is None: + raise TypeError("Missing 'stack_id' argument") + if commit_sha is None and 'commitSha' in kwargs: + commit_sha = kwargs['commitSha'] + + _setter("stack_id", stack_id) if commit_sha is not None: - pulumi.set(__self__, "commit_sha", commit_sha) + _setter("commit_sha", commit_sha) if keepers is not None: - pulumi.set(__self__, "keepers", keepers) + _setter("keepers", keepers) if proposed is not None: - pulumi.set(__self__, "proposed", proposed) + _setter("proposed", proposed) @property @pulumi.getter(name="stackId") @@ -96,14 +119,35 @@ def __init__(__self__, *, :param pulumi.Input[bool] proposed: Whether the run is a proposed run. Defaults to `false`. :param pulumi.Input[str] stack_id: ID of the stack on which the run is to be triggered. """ + _RunState._configure( + lambda key, value: pulumi.set(__self__, key, value), + commit_sha=commit_sha, + keepers=keepers, + proposed=proposed, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + proposed: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if commit_sha is None and 'commitSha' in kwargs: + commit_sha = kwargs['commitSha'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if commit_sha is not None: - pulumi.set(__self__, "commit_sha", commit_sha) + _setter("commit_sha", commit_sha) if keepers is not None: - pulumi.set(__self__, "keepers", keepers) + _setter("keepers", keepers) if proposed is not None: - pulumi.set(__self__, "proposed", proposed) + _setter("proposed", proposed) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="commitSha") @@ -225,6 +269,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + RunArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/scheduled_delete_task.py b/sdk/python/pulumi_spacelift/scheduled_delete_task.py new file mode 100644 index 0000000..4e297e0 --- /dev/null +++ b/sdk/python/pulumi_spacelift/scheduled_delete_task.py @@ -0,0 +1,384 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['ScheduledDeleteTaskArgs', 'ScheduledDeleteTask'] + +@pulumi.input_type +class ScheduledDeleteTaskArgs: + def __init__(__self__, *, + at: pulumi.Input[int], + stack_id: pulumi.Input[str], + delete_resources: Optional[pulumi.Input[bool]] = None, + schedule_id: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a ScheduledDeleteTask resource. + :param pulumi.Input[int] at: Timestamp (unix timestamp) at which time the scheduling should happen. + :param pulumi.Input[str] stack_id: ID of the stack for which to set up scheduling + :param pulumi.Input[bool] delete_resources: Indicates whether the resources of the stack should be deleted. + :param pulumi.Input[str] schedule_id: ID of the schedule + """ + ScheduledDeleteTaskArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + at=at, + stack_id=stack_id, + delete_resources=delete_resources, + schedule_id=schedule_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + at: Optional[pulumi.Input[int]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + delete_resources: Optional[pulumi.Input[bool]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if at is None: + raise TypeError("Missing 'at' argument") + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if stack_id is None: + raise TypeError("Missing 'stack_id' argument") + if delete_resources is None and 'deleteResources' in kwargs: + delete_resources = kwargs['deleteResources'] + if schedule_id is None and 'scheduleId' in kwargs: + schedule_id = kwargs['scheduleId'] + + _setter("at", at) + _setter("stack_id", stack_id) + if delete_resources is not None: + _setter("delete_resources", delete_resources) + if schedule_id is not None: + _setter("schedule_id", schedule_id) + + @property + @pulumi.getter + def at(self) -> pulumi.Input[int]: + """ + Timestamp (unix timestamp) at which time the scheduling should happen. + """ + return pulumi.get(self, "at") + + @at.setter + def at(self, value: pulumi.Input[int]): + pulumi.set(self, "at", value) + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> pulumi.Input[str]: + """ + ID of the stack for which to set up scheduling + """ + return pulumi.get(self, "stack_id") + + @stack_id.setter + def stack_id(self, value: pulumi.Input[str]): + pulumi.set(self, "stack_id", value) + + @property + @pulumi.getter(name="deleteResources") + def delete_resources(self) -> Optional[pulumi.Input[bool]]: + """ + Indicates whether the resources of the stack should be deleted. + """ + return pulumi.get(self, "delete_resources") + + @delete_resources.setter + def delete_resources(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "delete_resources", value) + + @property + @pulumi.getter(name="scheduleId") + def schedule_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the schedule + """ + return pulumi.get(self, "schedule_id") + + @schedule_id.setter + def schedule_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "schedule_id", value) + + +@pulumi.input_type +class _ScheduledDeleteTaskState: + def __init__(__self__, *, + at: Optional[pulumi.Input[int]] = None, + delete_resources: Optional[pulumi.Input[bool]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering ScheduledDeleteTask resources. + :param pulumi.Input[int] at: Timestamp (unix timestamp) at which time the scheduling should happen. + :param pulumi.Input[bool] delete_resources: Indicates whether the resources of the stack should be deleted. + :param pulumi.Input[str] schedule_id: ID of the schedule + :param pulumi.Input[str] stack_id: ID of the stack for which to set up scheduling + """ + _ScheduledDeleteTaskState._configure( + lambda key, value: pulumi.set(__self__, key, value), + at=at, + delete_resources=delete_resources, + schedule_id=schedule_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + at: Optional[pulumi.Input[int]] = None, + delete_resources: Optional[pulumi.Input[bool]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if delete_resources is None and 'deleteResources' in kwargs: + delete_resources = kwargs['deleteResources'] + if schedule_id is None and 'scheduleId' in kwargs: + schedule_id = kwargs['scheduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + if at is not None: + _setter("at", at) + if delete_resources is not None: + _setter("delete_resources", delete_resources) + if schedule_id is not None: + _setter("schedule_id", schedule_id) + if stack_id is not None: + _setter("stack_id", stack_id) + + @property + @pulumi.getter + def at(self) -> Optional[pulumi.Input[int]]: + """ + Timestamp (unix timestamp) at which time the scheduling should happen. + """ + return pulumi.get(self, "at") + + @at.setter + def at(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "at", value) + + @property + @pulumi.getter(name="deleteResources") + def delete_resources(self) -> Optional[pulumi.Input[bool]]: + """ + Indicates whether the resources of the stack should be deleted. + """ + return pulumi.get(self, "delete_resources") + + @delete_resources.setter + def delete_resources(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "delete_resources", value) + + @property + @pulumi.getter(name="scheduleId") + def schedule_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the schedule + """ + return pulumi.get(self, "schedule_id") + + @schedule_id.setter + def schedule_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "schedule_id", value) + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the stack for which to set up scheduling + """ + return pulumi.get(self, "stack_id") + + @stack_id.setter + def stack_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "stack_id", value) + + +class ScheduledDeleteTask(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + at: Optional[pulumi.Input[int]] = None, + delete_resources: Optional[pulumi.Input[bool]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + k8s_core = spacelift.Stack("k8s-core") + # ... + # at a given timestamp (unix) + k8s_core_delete = spacelift.ScheduledDeleteTask("k8s-core-delete", + stack_id=k8s_core.id, + at=1663336895, + delete_resources=True) + ``` + + ## Import + + ```sh + $ pulumi import spacelift:index/scheduledDeleteTask:ScheduledDeleteTask ireland-kubeconfig $STACK_ID/$SCHEDULED_DELETE_STACK_ID + ``` + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[int] at: Timestamp (unix timestamp) at which time the scheduling should happen. + :param pulumi.Input[bool] delete_resources: Indicates whether the resources of the stack should be deleted. + :param pulumi.Input[str] schedule_id: ID of the schedule + :param pulumi.Input[str] stack_id: ID of the stack for which to set up scheduling + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ScheduledDeleteTaskArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `ScheduledDeleteTask` represents a scheduling configuration for a Stack. It will trigger a stack deletion task at the given timestamp. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + k8s_core = spacelift.Stack("k8s-core") + # ... + # at a given timestamp (unix) + k8s_core_delete = spacelift.ScheduledDeleteTask("k8s-core-delete", + stack_id=k8s_core.id, + at=1663336895, + delete_resources=True) + ``` + + ## Import + + ```sh + $ pulumi import spacelift:index/scheduledDeleteTask:ScheduledDeleteTask ireland-kubeconfig $STACK_ID/$SCHEDULED_DELETE_STACK_ID + ``` + + :param str resource_name: The name of the resource. + :param ScheduledDeleteTaskArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(ScheduledDeleteTaskArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + ScheduledDeleteTaskArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + at: Optional[pulumi.Input[int]] = None, + delete_resources: Optional[pulumi.Input[bool]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ScheduledDeleteTaskArgs.__new__(ScheduledDeleteTaskArgs) + + if at is None and not opts.urn: + raise TypeError("Missing required property 'at'") + __props__.__dict__["at"] = at + __props__.__dict__["delete_resources"] = delete_resources + __props__.__dict__["schedule_id"] = schedule_id + if stack_id is None and not opts.urn: + raise TypeError("Missing required property 'stack_id'") + __props__.__dict__["stack_id"] = stack_id + super(ScheduledDeleteTask, __self__).__init__( + 'spacelift:index/scheduledDeleteTask:ScheduledDeleteTask', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + at: Optional[pulumi.Input[int]] = None, + delete_resources: Optional[pulumi.Input[bool]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None) -> 'ScheduledDeleteTask': + """ + Get an existing ScheduledDeleteTask resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[int] at: Timestamp (unix timestamp) at which time the scheduling should happen. + :param pulumi.Input[bool] delete_resources: Indicates whether the resources of the stack should be deleted. + :param pulumi.Input[str] schedule_id: ID of the schedule + :param pulumi.Input[str] stack_id: ID of the stack for which to set up scheduling + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ScheduledDeleteTaskState.__new__(_ScheduledDeleteTaskState) + + __props__.__dict__["at"] = at + __props__.__dict__["delete_resources"] = delete_resources + __props__.__dict__["schedule_id"] = schedule_id + __props__.__dict__["stack_id"] = stack_id + return ScheduledDeleteTask(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def at(self) -> pulumi.Output[int]: + """ + Timestamp (unix timestamp) at which time the scheduling should happen. + """ + return pulumi.get(self, "at") + + @property + @pulumi.getter(name="deleteResources") + def delete_resources(self) -> pulumi.Output[Optional[bool]]: + """ + Indicates whether the resources of the stack should be deleted. + """ + return pulumi.get(self, "delete_resources") + + @property + @pulumi.getter(name="scheduleId") + def schedule_id(self) -> pulumi.Output[str]: + """ + ID of the schedule + """ + return pulumi.get(self, "schedule_id") + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> pulumi.Output[str]: + """ + ID of the stack for which to set up scheduling + """ + return pulumi.get(self, "stack_id") + diff --git a/sdk/python/pulumi_spacelift/scheduled_task.py b/sdk/python/pulumi_spacelift/scheduled_task.py new file mode 100644 index 0000000..98c7d6a --- /dev/null +++ b/sdk/python/pulumi_spacelift/scheduled_task.py @@ -0,0 +1,506 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['ScheduledTaskArgs', 'ScheduledTask'] + +@pulumi.input_type +class ScheduledTaskArgs: + def __init__(__self__, *, + command: pulumi.Input[str], + stack_id: pulumi.Input[str], + at: Optional[pulumi.Input[int]] = None, + everies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + timezone: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a ScheduledTask resource. + :param pulumi.Input[str] command: Command that will be run. + :param pulumi.Input[str] stack_id: ID of the stack for which to set up the scheduled task + :param pulumi.Input[int] at: Timestamp (unix timestamp) at which time the scheduled task should happen. + :param pulumi.Input[Sequence[pulumi.Input[str]]] everies: List of cron schedule expressions based on which the scheduled task should be triggered. + :param pulumi.Input[str] schedule_id: ID of the schedule + :param pulumi.Input[str] timezone: Timezone in which the schedule is expressed. Defaults to `UTC`. + """ + ScheduledTaskArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + command=command, + stack_id=stack_id, + at=at, + everies=everies, + schedule_id=schedule_id, + timezone=timezone, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + command: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + at: Optional[pulumi.Input[int]] = None, + everies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + timezone: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if command is None: + raise TypeError("Missing 'command' argument") + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if stack_id is None: + raise TypeError("Missing 'stack_id' argument") + if schedule_id is None and 'scheduleId' in kwargs: + schedule_id = kwargs['scheduleId'] + + _setter("command", command) + _setter("stack_id", stack_id) + if at is not None: + _setter("at", at) + if everies is not None: + _setter("everies", everies) + if schedule_id is not None: + _setter("schedule_id", schedule_id) + if timezone is not None: + _setter("timezone", timezone) + + @property + @pulumi.getter + def command(self) -> pulumi.Input[str]: + """ + Command that will be run. + """ + return pulumi.get(self, "command") + + @command.setter + def command(self, value: pulumi.Input[str]): + pulumi.set(self, "command", value) + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> pulumi.Input[str]: + """ + ID of the stack for which to set up the scheduled task + """ + return pulumi.get(self, "stack_id") + + @stack_id.setter + def stack_id(self, value: pulumi.Input[str]): + pulumi.set(self, "stack_id", value) + + @property + @pulumi.getter + def at(self) -> Optional[pulumi.Input[int]]: + """ + Timestamp (unix timestamp) at which time the scheduled task should happen. + """ + return pulumi.get(self, "at") + + @at.setter + def at(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "at", value) + + @property + @pulumi.getter + def everies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + """ + List of cron schedule expressions based on which the scheduled task should be triggered. + """ + return pulumi.get(self, "everies") + + @everies.setter + def everies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "everies", value) + + @property + @pulumi.getter(name="scheduleId") + def schedule_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the schedule + """ + return pulumi.get(self, "schedule_id") + + @schedule_id.setter + def schedule_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "schedule_id", value) + + @property + @pulumi.getter + def timezone(self) -> Optional[pulumi.Input[str]]: + """ + Timezone in which the schedule is expressed. Defaults to `UTC`. + """ + return pulumi.get(self, "timezone") + + @timezone.setter + def timezone(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "timezone", value) + + +@pulumi.input_type +class _ScheduledTaskState: + def __init__(__self__, *, + at: Optional[pulumi.Input[int]] = None, + command: Optional[pulumi.Input[str]] = None, + everies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + timezone: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering ScheduledTask resources. + :param pulumi.Input[int] at: Timestamp (unix timestamp) at which time the scheduled task should happen. + :param pulumi.Input[str] command: Command that will be run. + :param pulumi.Input[Sequence[pulumi.Input[str]]] everies: List of cron schedule expressions based on which the scheduled task should be triggered. + :param pulumi.Input[str] schedule_id: ID of the schedule + :param pulumi.Input[str] stack_id: ID of the stack for which to set up the scheduled task + :param pulumi.Input[str] timezone: Timezone in which the schedule is expressed. Defaults to `UTC`. + """ + _ScheduledTaskState._configure( + lambda key, value: pulumi.set(__self__, key, value), + at=at, + command=command, + everies=everies, + schedule_id=schedule_id, + stack_id=stack_id, + timezone=timezone, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + at: Optional[pulumi.Input[int]] = None, + command: Optional[pulumi.Input[str]] = None, + everies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + timezone: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if schedule_id is None and 'scheduleId' in kwargs: + schedule_id = kwargs['scheduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + if at is not None: + _setter("at", at) + if command is not None: + _setter("command", command) + if everies is not None: + _setter("everies", everies) + if schedule_id is not None: + _setter("schedule_id", schedule_id) + if stack_id is not None: + _setter("stack_id", stack_id) + if timezone is not None: + _setter("timezone", timezone) + + @property + @pulumi.getter + def at(self) -> Optional[pulumi.Input[int]]: + """ + Timestamp (unix timestamp) at which time the scheduled task should happen. + """ + return pulumi.get(self, "at") + + @at.setter + def at(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "at", value) + + @property + @pulumi.getter + def command(self) -> Optional[pulumi.Input[str]]: + """ + Command that will be run. + """ + return pulumi.get(self, "command") + + @command.setter + def command(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "command", value) + + @property + @pulumi.getter + def everies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + """ + List of cron schedule expressions based on which the scheduled task should be triggered. + """ + return pulumi.get(self, "everies") + + @everies.setter + def everies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "everies", value) + + @property + @pulumi.getter(name="scheduleId") + def schedule_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the schedule + """ + return pulumi.get(self, "schedule_id") + + @schedule_id.setter + def schedule_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "schedule_id", value) + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the stack for which to set up the scheduled task + """ + return pulumi.get(self, "stack_id") + + @stack_id.setter + def stack_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "stack_id", value) + + @property + @pulumi.getter + def timezone(self) -> Optional[pulumi.Input[str]]: + """ + Timezone in which the schedule is expressed. Defaults to `UTC`. + """ + return pulumi.get(self, "timezone") + + @timezone.setter + def timezone(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "timezone", value) + + +class ScheduledTask(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + at: Optional[pulumi.Input[int]] = None, + command: Optional[pulumi.Input[str]] = None, + everies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + timezone: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `ScheduledTask` represents a scheduling configuration for a Stack. It will trigger task on the given schedule or timestamp + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + k8s_core = spacelift.Stack("k8s-core") + # ... + # create the resources of a stack on a given schedule + k8s_core_create = spacelift.ScheduledTask("k8s-core-create", + stack_id=k8s_core.id, + command="pulumi up -auto-approve", + everies=["0 7 * * 1-5"], + timezone="CET") + # destroy the resources of a stack on a given schedule + k8s_core_destroy_scheduled_task = spacelift.ScheduledTask("k8s-core-destroyScheduledTask", + stack_id=k8s_core.id, + command="terraform destroy -auto-approve", + everies=["0 21 * * 1-5"], + timezone="CET") + # at a given timestamp (unix) + k8s_core_destroy_index_scheduled_task_scheduled_task = spacelift.ScheduledTask("k8s-core-destroyIndex/scheduledTaskScheduledTask", + stack_id=k8s_core.id, + command="terraform destroy -auto-approve", + at=1663336895) + ``` + + ## Import + + ```sh + $ pulumi import spacelift:index/scheduledTask:ScheduledTask ireland-kubeconfig $STACK_ID/$SCHEDULED_TASK_ID + ``` + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[int] at: Timestamp (unix timestamp) at which time the scheduled task should happen. + :param pulumi.Input[str] command: Command that will be run. + :param pulumi.Input[Sequence[pulumi.Input[str]]] everies: List of cron schedule expressions based on which the scheduled task should be triggered. + :param pulumi.Input[str] schedule_id: ID of the schedule + :param pulumi.Input[str] stack_id: ID of the stack for which to set up the scheduled task + :param pulumi.Input[str] timezone: Timezone in which the schedule is expressed. Defaults to `UTC`. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ScheduledTaskArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `ScheduledTask` represents a scheduling configuration for a Stack. It will trigger task on the given schedule or timestamp + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + k8s_core = spacelift.Stack("k8s-core") + # ... + # create the resources of a stack on a given schedule + k8s_core_create = spacelift.ScheduledTask("k8s-core-create", + stack_id=k8s_core.id, + command="pulumi up -auto-approve", + everies=["0 7 * * 1-5"], + timezone="CET") + # destroy the resources of a stack on a given schedule + k8s_core_destroy_scheduled_task = spacelift.ScheduledTask("k8s-core-destroyScheduledTask", + stack_id=k8s_core.id, + command="terraform destroy -auto-approve", + everies=["0 21 * * 1-5"], + timezone="CET") + # at a given timestamp (unix) + k8s_core_destroy_index_scheduled_task_scheduled_task = spacelift.ScheduledTask("k8s-core-destroyIndex/scheduledTaskScheduledTask", + stack_id=k8s_core.id, + command="terraform destroy -auto-approve", + at=1663336895) + ``` + + ## Import + + ```sh + $ pulumi import spacelift:index/scheduledTask:ScheduledTask ireland-kubeconfig $STACK_ID/$SCHEDULED_TASK_ID + ``` + + :param str resource_name: The name of the resource. + :param ScheduledTaskArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(ScheduledTaskArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + ScheduledTaskArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + at: Optional[pulumi.Input[int]] = None, + command: Optional[pulumi.Input[str]] = None, + everies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + timezone: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ScheduledTaskArgs.__new__(ScheduledTaskArgs) + + __props__.__dict__["at"] = at + if command is None and not opts.urn: + raise TypeError("Missing required property 'command'") + __props__.__dict__["command"] = command + __props__.__dict__["everies"] = everies + __props__.__dict__["schedule_id"] = schedule_id + if stack_id is None and not opts.urn: + raise TypeError("Missing required property 'stack_id'") + __props__.__dict__["stack_id"] = stack_id + __props__.__dict__["timezone"] = timezone + super(ScheduledTask, __self__).__init__( + 'spacelift:index/scheduledTask:ScheduledTask', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + at: Optional[pulumi.Input[int]] = None, + command: Optional[pulumi.Input[str]] = None, + everies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + schedule_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + timezone: Optional[pulumi.Input[str]] = None) -> 'ScheduledTask': + """ + Get an existing ScheduledTask resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[int] at: Timestamp (unix timestamp) at which time the scheduled task should happen. + :param pulumi.Input[str] command: Command that will be run. + :param pulumi.Input[Sequence[pulumi.Input[str]]] everies: List of cron schedule expressions based on which the scheduled task should be triggered. + :param pulumi.Input[str] schedule_id: ID of the schedule + :param pulumi.Input[str] stack_id: ID of the stack for which to set up the scheduled task + :param pulumi.Input[str] timezone: Timezone in which the schedule is expressed. Defaults to `UTC`. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ScheduledTaskState.__new__(_ScheduledTaskState) + + __props__.__dict__["at"] = at + __props__.__dict__["command"] = command + __props__.__dict__["everies"] = everies + __props__.__dict__["schedule_id"] = schedule_id + __props__.__dict__["stack_id"] = stack_id + __props__.__dict__["timezone"] = timezone + return ScheduledTask(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def at(self) -> pulumi.Output[Optional[int]]: + """ + Timestamp (unix timestamp) at which time the scheduled task should happen. + """ + return pulumi.get(self, "at") + + @property + @pulumi.getter + def command(self) -> pulumi.Output[str]: + """ + Command that will be run. + """ + return pulumi.get(self, "command") + + @property + @pulumi.getter + def everies(self) -> pulumi.Output[Optional[Sequence[str]]]: + """ + List of cron schedule expressions based on which the scheduled task should be triggered. + """ + return pulumi.get(self, "everies") + + @property + @pulumi.getter(name="scheduleId") + def schedule_id(self) -> pulumi.Output[str]: + """ + ID of the schedule + """ + return pulumi.get(self, "schedule_id") + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> pulumi.Output[str]: + """ + ID of the stack for which to set up the scheduled task + """ + return pulumi.get(self, "stack_id") + + @property + @pulumi.getter + def timezone(self) -> pulumi.Output[Optional[str]]: + """ + Timezone in which the schedule is expressed. Defaults to `UTC`. + """ + return pulumi.get(self, "timezone") + diff --git a/sdk/python/pulumi_spacelift/space.py b/sdk/python/pulumi_spacelift/space.py index 6946c75..f650809 100644 --- a/sdk/python/pulumi_spacelift/space.py +++ b/sdk/python/pulumi_spacelift/space.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['SpaceArgs', 'Space'] @@ -16,23 +16,50 @@ class SpaceArgs: def __init__(__self__, *, description: Optional[pulumi.Input[str]] = None, inherit_entities: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, name: Optional[pulumi.Input[str]] = None, parent_space_id: Optional[pulumi.Input[str]] = None): """ The set of arguments for constructing a Space resource. :param pulumi.Input[str] description: free-form space description for users :param pulumi.Input[bool] inherit_entities: indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: list of labels describing a space :param pulumi.Input[str] name: name of the space :param pulumi.Input[str] parent_space_id: immutable ID (slug) of parent space. Defaults to `root`. """ + SpaceArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + inherit_entities=inherit_entities, + labels=labels, + name=name, + parent_space_id=parent_space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[pulumi.Input[str]] = None, + inherit_entities: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + parent_space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if inherit_entities is None and 'inheritEntities' in kwargs: + inherit_entities = kwargs['inheritEntities'] + if parent_space_id is None and 'parentSpaceId' in kwargs: + parent_space_id = kwargs['parentSpaceId'] + if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) if inherit_entities is not None: - pulumi.set(__self__, "inherit_entities", inherit_entities) + _setter("inherit_entities", inherit_entities) + if labels is not None: + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if parent_space_id is not None: - pulumi.set(__self__, "parent_space_id", parent_space_id) + _setter("parent_space_id", parent_space_id) @property @pulumi.getter @@ -58,6 +85,18 @@ def inherit_entities(self) -> Optional[pulumi.Input[bool]]: def inherit_entities(self, value: Optional[pulumi.Input[bool]]): pulumi.set(self, "inherit_entities", value) + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + """ + list of labels describing a space + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + @property @pulumi.getter def name(self) -> Optional[pulumi.Input[str]]: @@ -88,23 +127,50 @@ class _SpaceState: def __init__(__self__, *, description: Optional[pulumi.Input[str]] = None, inherit_entities: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, name: Optional[pulumi.Input[str]] = None, parent_space_id: Optional[pulumi.Input[str]] = None): """ Input properties used for looking up and filtering Space resources. :param pulumi.Input[str] description: free-form space description for users :param pulumi.Input[bool] inherit_entities: indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: list of labels describing a space :param pulumi.Input[str] name: name of the space :param pulumi.Input[str] parent_space_id: immutable ID (slug) of parent space. Defaults to `root`. """ + _SpaceState._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + inherit_entities=inherit_entities, + labels=labels, + name=name, + parent_space_id=parent_space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[pulumi.Input[str]] = None, + inherit_entities: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + parent_space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if inherit_entities is None and 'inheritEntities' in kwargs: + inherit_entities = kwargs['inheritEntities'] + if parent_space_id is None and 'parentSpaceId' in kwargs: + parent_space_id = kwargs['parentSpaceId'] + if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) if inherit_entities is not None: - pulumi.set(__self__, "inherit_entities", inherit_entities) + _setter("inherit_entities", inherit_entities) + if labels is not None: + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if parent_space_id is not None: - pulumi.set(__self__, "parent_space_id", parent_space_id) + _setter("parent_space_id", parent_space_id) @property @pulumi.getter @@ -130,6 +196,18 @@ def inherit_entities(self) -> Optional[pulumi.Input[bool]]: def inherit_entities(self, value: Optional[pulumi.Input[bool]]): pulumi.set(self, "inherit_entities", value) + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + """ + list of labels describing a space + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + @property @pulumi.getter def name(self) -> Optional[pulumi.Input[str]]: @@ -162,6 +240,7 @@ def __init__(__self__, opts: Optional[pulumi.ResourceOptions] = None, description: Optional[pulumi.Input[str]] = None, inherit_entities: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, name: Optional[pulumi.Input[str]] = None, parent_space_id: Optional[pulumi.Input[str]] = None, __props__=None): @@ -192,6 +271,7 @@ def __init__(__self__, :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[str] description: free-form space description for users :param pulumi.Input[bool] inherit_entities: indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: list of labels describing a space :param pulumi.Input[str] name: name of the space :param pulumi.Input[str] parent_space_id: immutable ID (slug) of parent space. Defaults to `root`. """ @@ -234,6 +314,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + SpaceArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -241,6 +325,7 @@ def _internal_init(__self__, opts: Optional[pulumi.ResourceOptions] = None, description: Optional[pulumi.Input[str]] = None, inherit_entities: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, name: Optional[pulumi.Input[str]] = None, parent_space_id: Optional[pulumi.Input[str]] = None, __props__=None): @@ -254,6 +339,7 @@ def _internal_init(__self__, __props__.__dict__["description"] = description __props__.__dict__["inherit_entities"] = inherit_entities + __props__.__dict__["labels"] = labels __props__.__dict__["name"] = name __props__.__dict__["parent_space_id"] = parent_space_id super(Space, __self__).__init__( @@ -268,6 +354,7 @@ def get(resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, description: Optional[pulumi.Input[str]] = None, inherit_entities: Optional[pulumi.Input[bool]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, name: Optional[pulumi.Input[str]] = None, parent_space_id: Optional[pulumi.Input[str]] = None) -> 'Space': """ @@ -279,6 +366,7 @@ def get(resource_name: str, :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[str] description: free-form space description for users :param pulumi.Input[bool] inherit_entities: indication whether access to this space inherits read access to entities from the parent space. Defaults to `false`. + :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: list of labels describing a space :param pulumi.Input[str] name: name of the space :param pulumi.Input[str] parent_space_id: immutable ID (slug) of parent space. Defaults to `root`. """ @@ -288,6 +376,7 @@ def get(resource_name: str, __props__.__dict__["description"] = description __props__.__dict__["inherit_entities"] = inherit_entities + __props__.__dict__["labels"] = labels __props__.__dict__["name"] = name __props__.__dict__["parent_space_id"] = parent_space_id return Space(resource_name, opts=opts, __props__=__props__) @@ -308,6 +397,14 @@ def inherit_entities(self) -> pulumi.Output[Optional[bool]]: """ return pulumi.get(self, "inherit_entities") + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Sequence[str]]]: + """ + list of labels describing a space + """ + return pulumi.get(self, "labels") + @property @pulumi.getter def name(self) -> pulumi.Output[str]: diff --git a/sdk/python/pulumi_spacelift/stack.py b/sdk/python/pulumi_spacelift/stack.py index 92c9ce9..5349d44 100644 --- a/sdk/python/pulumi_spacelift/stack.py +++ b/sdk/python/pulumi_spacelift/stack.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities from . import outputs from ._inputs import * @@ -24,6 +24,7 @@ def __init__(__self__, *, after_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_runs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, ansible: Optional[pulumilib.Input['StackAnsibleArgs']] = None, autodeploy: Optional[pulumilib.Input[bool]] = None, autoretry: Optional[pulumilib.Input[bool]] = None, @@ -50,13 +51,17 @@ def __init__(__self__, *, project_root: Optional[pulumilib.Input[str]] = None, protect_from_deletion: Optional[pulumilib.Input[bool]] = None, pulumi: Optional[pulumilib.Input['StackPulumiArgs']] = None, + raw_git: Optional[pulumilib.Input['StackRawGitArgs']] = None, runner_image: Optional[pulumilib.Input[str]] = None, showcase: Optional[pulumilib.Input['StackShowcaseArgs']] = None, slug: Optional[pulumilib.Input[str]] = None, space_id: Optional[pulumilib.Input[str]] = None, + terraform_external_state_access: Optional[pulumilib.Input[bool]] = None, terraform_smart_sanitization: Optional[pulumilib.Input[bool]] = None, terraform_version: Optional[pulumilib.Input[str]] = None, + terraform_workflow_tool: Optional[pulumilib.Input[str]] = None, terraform_workspace: Optional[pulumilib.Input[str]] = None, + terragrunt: Optional[pulumilib.Input['StackTerragruntArgs']] = None, worker_pool_id: Optional[pulumilib.Input[str]] = None): """ The set of arguments for constructing a Stack resource. @@ -68,6 +73,7 @@ def __init__(__self__, *, :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_inits: List of after-init scripts :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_performs: List of after-perform scripts :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_plans: List of after-plan scripts + :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_runs: List of after-run scripts :param pulumilib.Input['StackAnsibleArgs'] ansible: Ansible-specific configuration. Presence means this Stack is an Ansible Stack. :param pulumilib.Input[bool] autodeploy: Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. :param pulumilib.Input[bool] autoretry: Indicates whether obsolete proposed changes should automatically be retried. Defaults to `false`. @@ -82,8 +88,8 @@ def __init__(__self__, *, :param pulumilib.Input['StackCloudformationArgs'] cloudformation: CloudFormation-specific configuration. Presence means this Stack is a CloudFormation Stack. :param pulumilib.Input[str] description: Free-form stack description for users :param pulumilib.Input[bool] enable_local_preview: Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. - :param pulumilib.Input[bool] github_action_deploy: Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. - :param pulumilib.Input['StackGithubEnterpriseArgs'] github_enterprise: GitHub Enterprise (self-hosted) VCS settings + :param pulumilib.Input[bool] github_action_deploy: Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. + :param pulumilib.Input['StackGithubEnterpriseArgs'] github_enterprise: VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) :param pulumilib.Input['StackGitlabArgs'] gitlab: GitLab VCS settings :param pulumilib.Input[str] import_state: State file to upload when creating a new stack :param pulumilib.Input[str] import_state_file: Path to the state file to upload when creating a new stack @@ -93,98 +99,281 @@ def __init__(__self__, *, :param pulumilib.Input[str] project_root: Project root is the optional directory relative to the workspace root containing the entrypoint to the Stack. :param pulumilib.Input[bool] protect_from_deletion: Protect this stack from accidental deletion. If set, attempts to delete this stack will fail. Defaults to `false`. :param pulumilib.Input['StackPulumiArgs'] pulumi: Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. + :param pulumilib.Input['StackRawGitArgs'] raw_git: One-way VCS integration using a raw Git repository link :param pulumilib.Input[str] runner_image: Name of the Docker image used to process Runs :param pulumilib.Input[str] slug: Allows setting the custom ID (slug) for the stack - :param pulumilib.Input[str] space_id: ID (slug) of the space the stack is in + :param pulumilib.Input[str] space_id: ID (slug) of the space the stack is in. Defaults to `legacy`. + :param pulumilib.Input[bool] terraform_external_state_access: Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. :param pulumilib.Input[bool] terraform_smart_sanitization: Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. Defaults to `false`. :param pulumilib.Input[str] terraform_version: Terraform version to use + :param pulumilib.Input[str] terraform_workflow_tool: Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. :param pulumilib.Input[str] terraform_workspace: Terraform workspace to select - :param pulumilib.Input[str] worker_pool_id: ID of the worker pool to use - """ - pulumilib.set(__self__, "branch", branch) - pulumilib.set(__self__, "repository", repository) + :param pulumilib.Input['StackTerragruntArgs'] terragrunt: Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + :param pulumilib.Input[str] worker_pool_id: ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. + """ + StackArgs._configure( + lambda key, value: pulumilib.set(__self__, key, value), + branch=branch, + repository=repository, + administrative=administrative, + after_applies=after_applies, + after_destroys=after_destroys, + after_inits=after_inits, + after_performs=after_performs, + after_plans=after_plans, + after_runs=after_runs, + ansible=ansible, + autodeploy=autodeploy, + autoretry=autoretry, + azure_devops=azure_devops, + before_applies=before_applies, + before_destroys=before_destroys, + before_inits=before_inits, + before_performs=before_performs, + before_plans=before_plans, + bitbucket_cloud=bitbucket_cloud, + bitbucket_datacenter=bitbucket_datacenter, + cloudformation=cloudformation, + description=description, + enable_local_preview=enable_local_preview, + github_action_deploy=github_action_deploy, + github_enterprise=github_enterprise, + gitlab=gitlab, + import_state=import_state, + import_state_file=import_state_file, + kubernetes=kubernetes, + labels=labels, + manage_state=manage_state, + name=name, + project_root=project_root, + protect_from_deletion=protect_from_deletion, + pulumi=pulumi, + raw_git=raw_git, + runner_image=runner_image, + showcase=showcase, + slug=slug, + space_id=space_id, + terraform_external_state_access=terraform_external_state_access, + terraform_smart_sanitization=terraform_smart_sanitization, + terraform_version=terraform_version, + terraform_workflow_tool=terraform_workflow_tool, + terraform_workspace=terraform_workspace, + terragrunt=terragrunt, + worker_pool_id=worker_pool_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + branch: Optional[pulumilib.Input[str]] = None, + repository: Optional[pulumilib.Input[str]] = None, + administrative: Optional[pulumilib.Input[bool]] = None, + after_applies: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_destroys: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_runs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + ansible: Optional[pulumilib.Input['StackAnsibleArgs']] = None, + autodeploy: Optional[pulumilib.Input[bool]] = None, + autoretry: Optional[pulumilib.Input[bool]] = None, + azure_devops: Optional[pulumilib.Input['StackAzureDevopsArgs']] = None, + before_applies: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + before_destroys: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + before_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + before_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + before_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + bitbucket_cloud: Optional[pulumilib.Input['StackBitbucketCloudArgs']] = None, + bitbucket_datacenter: Optional[pulumilib.Input['StackBitbucketDatacenterArgs']] = None, + cloudformation: Optional[pulumilib.Input['StackCloudformationArgs']] = None, + description: Optional[pulumilib.Input[str]] = None, + enable_local_preview: Optional[pulumilib.Input[bool]] = None, + github_action_deploy: Optional[pulumilib.Input[bool]] = None, + github_enterprise: Optional[pulumilib.Input['StackGithubEnterpriseArgs']] = None, + gitlab: Optional[pulumilib.Input['StackGitlabArgs']] = None, + import_state: Optional[pulumilib.Input[str]] = None, + import_state_file: Optional[pulumilib.Input[str]] = None, + kubernetes: Optional[pulumilib.Input['StackKubernetesArgs']] = None, + labels: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + manage_state: Optional[pulumilib.Input[bool]] = None, + name: Optional[pulumilib.Input[str]] = None, + project_root: Optional[pulumilib.Input[str]] = None, + protect_from_deletion: Optional[pulumilib.Input[bool]] = None, + pulumi: Optional[pulumilib.Input['StackPulumiArgs']] = None, + raw_git: Optional[pulumilib.Input['StackRawGitArgs']] = None, + runner_image: Optional[pulumilib.Input[str]] = None, + showcase: Optional[pulumilib.Input['StackShowcaseArgs']] = None, + slug: Optional[pulumilib.Input[str]] = None, + space_id: Optional[pulumilib.Input[str]] = None, + terraform_external_state_access: Optional[pulumilib.Input[bool]] = None, + terraform_smart_sanitization: Optional[pulumilib.Input[bool]] = None, + terraform_version: Optional[pulumilib.Input[str]] = None, + terraform_workflow_tool: Optional[pulumilib.Input[str]] = None, + terraform_workspace: Optional[pulumilib.Input[str]] = None, + terragrunt: Optional[pulumilib.Input['StackTerragruntArgs']] = None, + worker_pool_id: Optional[pulumilib.Input[str]] = None, + opts: Optional[pulumilib.ResourceOptions] = None, + **kwargs): + if branch is None: + raise TypeError("Missing 'branch' argument") + if repository is None: + raise TypeError("Missing 'repository' argument") + if after_applies is None and 'afterApplies' in kwargs: + after_applies = kwargs['afterApplies'] + if after_destroys is None and 'afterDestroys' in kwargs: + after_destroys = kwargs['afterDestroys'] + if after_inits is None and 'afterInits' in kwargs: + after_inits = kwargs['afterInits'] + if after_performs is None and 'afterPerforms' in kwargs: + after_performs = kwargs['afterPerforms'] + if after_plans is None and 'afterPlans' in kwargs: + after_plans = kwargs['afterPlans'] + if after_runs is None and 'afterRuns' in kwargs: + after_runs = kwargs['afterRuns'] + if azure_devops is None and 'azureDevops' in kwargs: + azure_devops = kwargs['azureDevops'] + if before_applies is None and 'beforeApplies' in kwargs: + before_applies = kwargs['beforeApplies'] + if before_destroys is None and 'beforeDestroys' in kwargs: + before_destroys = kwargs['beforeDestroys'] + if before_inits is None and 'beforeInits' in kwargs: + before_inits = kwargs['beforeInits'] + if before_performs is None and 'beforePerforms' in kwargs: + before_performs = kwargs['beforePerforms'] + if before_plans is None and 'beforePlans' in kwargs: + before_plans = kwargs['beforePlans'] + if bitbucket_cloud is None and 'bitbucketCloud' in kwargs: + bitbucket_cloud = kwargs['bitbucketCloud'] + if bitbucket_datacenter is None and 'bitbucketDatacenter' in kwargs: + bitbucket_datacenter = kwargs['bitbucketDatacenter'] + if enable_local_preview is None and 'enableLocalPreview' in kwargs: + enable_local_preview = kwargs['enableLocalPreview'] + if github_action_deploy is None and 'githubActionDeploy' in kwargs: + github_action_deploy = kwargs['githubActionDeploy'] + if github_enterprise is None and 'githubEnterprise' in kwargs: + github_enterprise = kwargs['githubEnterprise'] + if import_state is None and 'importState' in kwargs: + import_state = kwargs['importState'] + if import_state_file is None and 'importStateFile' in kwargs: + import_state_file = kwargs['importStateFile'] + if manage_state is None and 'manageState' in kwargs: + manage_state = kwargs['manageState'] + if project_root is None and 'projectRoot' in kwargs: + project_root = kwargs['projectRoot'] + if protect_from_deletion is None and 'protectFromDeletion' in kwargs: + protect_from_deletion = kwargs['protectFromDeletion'] + if raw_git is None and 'rawGit' in kwargs: + raw_git = kwargs['rawGit'] + if runner_image is None and 'runnerImage' in kwargs: + runner_image = kwargs['runnerImage'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if terraform_external_state_access is None and 'terraformExternalStateAccess' in kwargs: + terraform_external_state_access = kwargs['terraformExternalStateAccess'] + if terraform_smart_sanitization is None and 'terraformSmartSanitization' in kwargs: + terraform_smart_sanitization = kwargs['terraformSmartSanitization'] + if terraform_version is None and 'terraformVersion' in kwargs: + terraform_version = kwargs['terraformVersion'] + if terraform_workflow_tool is None and 'terraformWorkflowTool' in kwargs: + terraform_workflow_tool = kwargs['terraformWorkflowTool'] + if terraform_workspace is None and 'terraformWorkspace' in kwargs: + terraform_workspace = kwargs['terraformWorkspace'] + if worker_pool_id is None and 'workerPoolId' in kwargs: + worker_pool_id = kwargs['workerPoolId'] + + _setter("branch", branch) + _setter("repository", repository) if administrative is not None: - pulumilib.set(__self__, "administrative", administrative) + _setter("administrative", administrative) if after_applies is not None: - pulumilib.set(__self__, "after_applies", after_applies) + _setter("after_applies", after_applies) if after_destroys is not None: - pulumilib.set(__self__, "after_destroys", after_destroys) + _setter("after_destroys", after_destroys) if after_inits is not None: - pulumilib.set(__self__, "after_inits", after_inits) + _setter("after_inits", after_inits) if after_performs is not None: - pulumilib.set(__self__, "after_performs", after_performs) + _setter("after_performs", after_performs) if after_plans is not None: - pulumilib.set(__self__, "after_plans", after_plans) + _setter("after_plans", after_plans) + if after_runs is not None: + _setter("after_runs", after_runs) if ansible is not None: - pulumilib.set(__self__, "ansible", ansible) + _setter("ansible", ansible) if autodeploy is not None: - pulumilib.set(__self__, "autodeploy", autodeploy) + _setter("autodeploy", autodeploy) if autoretry is not None: - pulumilib.set(__self__, "autoretry", autoretry) + _setter("autoretry", autoretry) if azure_devops is not None: - pulumilib.set(__self__, "azure_devops", azure_devops) + _setter("azure_devops", azure_devops) if before_applies is not None: - pulumilib.set(__self__, "before_applies", before_applies) + _setter("before_applies", before_applies) if before_destroys is not None: - pulumilib.set(__self__, "before_destroys", before_destroys) + _setter("before_destroys", before_destroys) if before_inits is not None: - pulumilib.set(__self__, "before_inits", before_inits) + _setter("before_inits", before_inits) if before_performs is not None: - pulumilib.set(__self__, "before_performs", before_performs) + _setter("before_performs", before_performs) if before_plans is not None: - pulumilib.set(__self__, "before_plans", before_plans) + _setter("before_plans", before_plans) if bitbucket_cloud is not None: - pulumilib.set(__self__, "bitbucket_cloud", bitbucket_cloud) + _setter("bitbucket_cloud", bitbucket_cloud) if bitbucket_datacenter is not None: - pulumilib.set(__self__, "bitbucket_datacenter", bitbucket_datacenter) + _setter("bitbucket_datacenter", bitbucket_datacenter) if cloudformation is not None: - pulumilib.set(__self__, "cloudformation", cloudformation) + _setter("cloudformation", cloudformation) if description is not None: - pulumilib.set(__self__, "description", description) + _setter("description", description) if enable_local_preview is not None: - pulumilib.set(__self__, "enable_local_preview", enable_local_preview) + _setter("enable_local_preview", enable_local_preview) if github_action_deploy is not None: - pulumilib.set(__self__, "github_action_deploy", github_action_deploy) + _setter("github_action_deploy", github_action_deploy) if github_enterprise is not None: - pulumilib.set(__self__, "github_enterprise", github_enterprise) + _setter("github_enterprise", github_enterprise) if gitlab is not None: - pulumilib.set(__self__, "gitlab", gitlab) + _setter("gitlab", gitlab) if import_state is not None: - pulumilib.set(__self__, "import_state", import_state) + _setter("import_state", import_state) if import_state_file is not None: - pulumilib.set(__self__, "import_state_file", import_state_file) + _setter("import_state_file", import_state_file) if kubernetes is not None: - pulumilib.set(__self__, "kubernetes", kubernetes) + _setter("kubernetes", kubernetes) if labels is not None: - pulumilib.set(__self__, "labels", labels) + _setter("labels", labels) if manage_state is not None: - pulumilib.set(__self__, "manage_state", manage_state) + _setter("manage_state", manage_state) if name is not None: - pulumilib.set(__self__, "name", name) + _setter("name", name) if project_root is not None: - pulumilib.set(__self__, "project_root", project_root) + _setter("project_root", project_root) if protect_from_deletion is not None: - pulumilib.set(__self__, "protect_from_deletion", protect_from_deletion) + _setter("protect_from_deletion", protect_from_deletion) if pulumi is not None: - pulumilib.set(__self__, "pulumi", pulumi) + _setter("pulumi", pulumi) + if raw_git is not None: + _setter("raw_git", raw_git) if runner_image is not None: - pulumilib.set(__self__, "runner_image", runner_image) + _setter("runner_image", runner_image) if showcase is not None: - pulumilib.set(__self__, "showcase", showcase) + _setter("showcase", showcase) if slug is not None: - pulumilib.set(__self__, "slug", slug) + _setter("slug", slug) if space_id is not None: - pulumilib.set(__self__, "space_id", space_id) + _setter("space_id", space_id) + if terraform_external_state_access is not None: + _setter("terraform_external_state_access", terraform_external_state_access) if terraform_smart_sanitization is not None: - pulumilib.set(__self__, "terraform_smart_sanitization", terraform_smart_sanitization) + _setter("terraform_smart_sanitization", terraform_smart_sanitization) if terraform_version is not None: - pulumilib.set(__self__, "terraform_version", terraform_version) + _setter("terraform_version", terraform_version) + if terraform_workflow_tool is not None: + _setter("terraform_workflow_tool", terraform_workflow_tool) if terraform_workspace is not None: - pulumilib.set(__self__, "terraform_workspace", terraform_workspace) + _setter("terraform_workspace", terraform_workspace) + if terragrunt is not None: + _setter("terragrunt", terragrunt) if worker_pool_id is not None: - pulumilib.set(__self__, "worker_pool_id", worker_pool_id) + _setter("worker_pool_id", worker_pool_id) @property @pulumilib.getter @@ -282,6 +471,18 @@ def after_plans(self) -> Optional[pulumilib.Input[Sequence[pulumilib.Input[str]] def after_plans(self, value: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]]): pulumilib.set(self, "after_plans", value) + @property + @pulumilib.getter(name="afterRuns") + def after_runs(self) -> Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]]: + """ + List of after-run scripts + """ + return pulumilib.get(self, "after_runs") + + @after_runs.setter + def after_runs(self, value: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]]): + pulumilib.set(self, "after_runs", value) + @property @pulumilib.getter def ansible(self) -> Optional[pulumilib.Input['StackAnsibleArgs']]: @@ -454,7 +655,7 @@ def enable_local_preview(self, value: Optional[pulumilib.Input[bool]]): @pulumilib.getter(name="githubActionDeploy") def github_action_deploy(self) -> Optional[pulumilib.Input[bool]]: """ - Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. """ return pulumilib.get(self, "github_action_deploy") @@ -466,7 +667,7 @@ def github_action_deploy(self, value: Optional[pulumilib.Input[bool]]): @pulumilib.getter(name="githubEnterprise") def github_enterprise(self) -> Optional[pulumilib.Input['StackGithubEnterpriseArgs']]: """ - GitHub Enterprise (self-hosted) VCS settings + VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) """ return pulumilib.get(self, "github_enterprise") @@ -591,6 +792,18 @@ def pulumi(self) -> Optional[pulumilib.Input['StackPulumiArgs']]: def pulumi(self, value: Optional[pulumilib.Input['StackPulumiArgs']]): pulumilib.set(self, "pulumi", value) + @property + @pulumilib.getter(name="rawGit") + def raw_git(self) -> Optional[pulumilib.Input['StackRawGitArgs']]: + """ + One-way VCS integration using a raw Git repository link + """ + return pulumilib.get(self, "raw_git") + + @raw_git.setter + def raw_git(self, value: Optional[pulumilib.Input['StackRawGitArgs']]): + pulumilib.set(self, "raw_git", value) + @property @pulumilib.getter(name="runnerImage") def runner_image(self) -> Optional[pulumilib.Input[str]]: @@ -628,7 +841,7 @@ def slug(self, value: Optional[pulumilib.Input[str]]): @pulumilib.getter(name="spaceId") def space_id(self) -> Optional[pulumilib.Input[str]]: """ - ID (slug) of the space the stack is in + ID (slug) of the space the stack is in. Defaults to `legacy`. """ return pulumilib.get(self, "space_id") @@ -636,6 +849,18 @@ def space_id(self) -> Optional[pulumilib.Input[str]]: def space_id(self, value: Optional[pulumilib.Input[str]]): pulumilib.set(self, "space_id", value) + @property + @pulumilib.getter(name="terraformExternalStateAccess") + def terraform_external_state_access(self) -> Optional[pulumilib.Input[bool]]: + """ + Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + """ + return pulumilib.get(self, "terraform_external_state_access") + + @terraform_external_state_access.setter + def terraform_external_state_access(self, value: Optional[pulumilib.Input[bool]]): + pulumilib.set(self, "terraform_external_state_access", value) + @property @pulumilib.getter(name="terraformSmartSanitization") def terraform_smart_sanitization(self) -> Optional[pulumilib.Input[bool]]: @@ -662,6 +887,18 @@ def terraform_version(self) -> Optional[pulumilib.Input[str]]: def terraform_version(self, value: Optional[pulumilib.Input[str]]): pulumilib.set(self, "terraform_version", value) + @property + @pulumilib.getter(name="terraformWorkflowTool") + def terraform_workflow_tool(self) -> Optional[pulumilib.Input[str]]: + """ + Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + """ + return pulumilib.get(self, "terraform_workflow_tool") + + @terraform_workflow_tool.setter + def terraform_workflow_tool(self, value: Optional[pulumilib.Input[str]]): + pulumilib.set(self, "terraform_workflow_tool", value) + @property @pulumilib.getter(name="terraformWorkspace") def terraform_workspace(self) -> Optional[pulumilib.Input[str]]: @@ -674,11 +911,23 @@ def terraform_workspace(self) -> Optional[pulumilib.Input[str]]: def terraform_workspace(self, value: Optional[pulumilib.Input[str]]): pulumilib.set(self, "terraform_workspace", value) + @property + @pulumilib.getter + def terragrunt(self) -> Optional[pulumilib.Input['StackTerragruntArgs']]: + """ + Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + """ + return pulumilib.get(self, "terragrunt") + + @terragrunt.setter + def terragrunt(self, value: Optional[pulumilib.Input['StackTerragruntArgs']]): + pulumilib.set(self, "terragrunt", value) + @property @pulumilib.getter(name="workerPoolId") def worker_pool_id(self) -> Optional[pulumilib.Input[str]]: """ - ID of the worker pool to use + ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. """ return pulumilib.get(self, "worker_pool_id") @@ -696,6 +945,7 @@ def __init__(__self__, *, after_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_runs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, ansible: Optional[pulumilib.Input['StackAnsibleArgs']] = None, autodeploy: Optional[pulumilib.Input[bool]] = None, autoretry: Optional[pulumilib.Input[bool]] = None, @@ -724,14 +974,18 @@ def __init__(__self__, *, project_root: Optional[pulumilib.Input[str]] = None, protect_from_deletion: Optional[pulumilib.Input[bool]] = None, pulumi: Optional[pulumilib.Input['StackPulumiArgs']] = None, + raw_git: Optional[pulumilib.Input['StackRawGitArgs']] = None, repository: Optional[pulumilib.Input[str]] = None, runner_image: Optional[pulumilib.Input[str]] = None, showcase: Optional[pulumilib.Input['StackShowcaseArgs']] = None, slug: Optional[pulumilib.Input[str]] = None, space_id: Optional[pulumilib.Input[str]] = None, + terraform_external_state_access: Optional[pulumilib.Input[bool]] = None, terraform_smart_sanitization: Optional[pulumilib.Input[bool]] = None, terraform_version: Optional[pulumilib.Input[str]] = None, + terraform_workflow_tool: Optional[pulumilib.Input[str]] = None, terraform_workspace: Optional[pulumilib.Input[str]] = None, + terragrunt: Optional[pulumilib.Input['StackTerragruntArgs']] = None, worker_pool_id: Optional[pulumilib.Input[str]] = None): """ Input properties used for looking up and filtering Stack resources. @@ -741,6 +995,7 @@ def __init__(__self__, *, :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_inits: List of after-init scripts :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_performs: List of after-perform scripts :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_plans: List of after-plan scripts + :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_runs: List of after-run scripts :param pulumilib.Input['StackAnsibleArgs'] ansible: Ansible-specific configuration. Presence means this Stack is an Ansible Stack. :param pulumilib.Input[bool] autodeploy: Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. :param pulumilib.Input[bool] autoretry: Indicates whether obsolete proposed changes should automatically be retried. Defaults to `false`. @@ -757,8 +1012,8 @@ def __init__(__self__, *, :param pulumilib.Input['StackCloudformationArgs'] cloudformation: CloudFormation-specific configuration. Presence means this Stack is a CloudFormation Stack. :param pulumilib.Input[str] description: Free-form stack description for users :param pulumilib.Input[bool] enable_local_preview: Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. - :param pulumilib.Input[bool] github_action_deploy: Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. - :param pulumilib.Input['StackGithubEnterpriseArgs'] github_enterprise: GitHub Enterprise (self-hosted) VCS settings + :param pulumilib.Input[bool] github_action_deploy: Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. + :param pulumilib.Input['StackGithubEnterpriseArgs'] github_enterprise: VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) :param pulumilib.Input['StackGitlabArgs'] gitlab: GitLab VCS settings :param pulumilib.Input[str] import_state: State file to upload when creating a new stack :param pulumilib.Input[str] import_state_file: Path to the state file to upload when creating a new stack @@ -768,103 +1023,286 @@ def __init__(__self__, *, :param pulumilib.Input[str] project_root: Project root is the optional directory relative to the workspace root containing the entrypoint to the Stack. :param pulumilib.Input[bool] protect_from_deletion: Protect this stack from accidental deletion. If set, attempts to delete this stack will fail. Defaults to `false`. :param pulumilib.Input['StackPulumiArgs'] pulumi: Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. + :param pulumilib.Input['StackRawGitArgs'] raw_git: One-way VCS integration using a raw Git repository link :param pulumilib.Input[str] repository: Name of the repository, without the owner part :param pulumilib.Input[str] runner_image: Name of the Docker image used to process Runs :param pulumilib.Input[str] slug: Allows setting the custom ID (slug) for the stack - :param pulumilib.Input[str] space_id: ID (slug) of the space the stack is in + :param pulumilib.Input[str] space_id: ID (slug) of the space the stack is in. Defaults to `legacy`. + :param pulumilib.Input[bool] terraform_external_state_access: Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. :param pulumilib.Input[bool] terraform_smart_sanitization: Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. Defaults to `false`. :param pulumilib.Input[str] terraform_version: Terraform version to use + :param pulumilib.Input[str] terraform_workflow_tool: Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. :param pulumilib.Input[str] terraform_workspace: Terraform workspace to select - :param pulumilib.Input[str] worker_pool_id: ID of the worker pool to use - """ + :param pulumilib.Input['StackTerragruntArgs'] terragrunt: Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + :param pulumilib.Input[str] worker_pool_id: ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. + """ + _StackState._configure( + lambda key, value: pulumilib.set(__self__, key, value), + administrative=administrative, + after_applies=after_applies, + after_destroys=after_destroys, + after_inits=after_inits, + after_performs=after_performs, + after_plans=after_plans, + after_runs=after_runs, + ansible=ansible, + autodeploy=autodeploy, + autoretry=autoretry, + aws_assume_role_policy_statement=aws_assume_role_policy_statement, + azure_devops=azure_devops, + before_applies=before_applies, + before_destroys=before_destroys, + before_inits=before_inits, + before_performs=before_performs, + before_plans=before_plans, + bitbucket_cloud=bitbucket_cloud, + bitbucket_datacenter=bitbucket_datacenter, + branch=branch, + cloudformation=cloudformation, + description=description, + enable_local_preview=enable_local_preview, + github_action_deploy=github_action_deploy, + github_enterprise=github_enterprise, + gitlab=gitlab, + import_state=import_state, + import_state_file=import_state_file, + kubernetes=kubernetes, + labels=labels, + manage_state=manage_state, + name=name, + project_root=project_root, + protect_from_deletion=protect_from_deletion, + pulumi=pulumi, + raw_git=raw_git, + repository=repository, + runner_image=runner_image, + showcase=showcase, + slug=slug, + space_id=space_id, + terraform_external_state_access=terraform_external_state_access, + terraform_smart_sanitization=terraform_smart_sanitization, + terraform_version=terraform_version, + terraform_workflow_tool=terraform_workflow_tool, + terraform_workspace=terraform_workspace, + terragrunt=terragrunt, + worker_pool_id=worker_pool_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + administrative: Optional[pulumilib.Input[bool]] = None, + after_applies: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_destroys: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_runs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + ansible: Optional[pulumilib.Input['StackAnsibleArgs']] = None, + autodeploy: Optional[pulumilib.Input[bool]] = None, + autoretry: Optional[pulumilib.Input[bool]] = None, + aws_assume_role_policy_statement: Optional[pulumilib.Input[str]] = None, + azure_devops: Optional[pulumilib.Input['StackAzureDevopsArgs']] = None, + before_applies: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + before_destroys: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + before_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + before_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + before_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + bitbucket_cloud: Optional[pulumilib.Input['StackBitbucketCloudArgs']] = None, + bitbucket_datacenter: Optional[pulumilib.Input['StackBitbucketDatacenterArgs']] = None, + branch: Optional[pulumilib.Input[str]] = None, + cloudformation: Optional[pulumilib.Input['StackCloudformationArgs']] = None, + description: Optional[pulumilib.Input[str]] = None, + enable_local_preview: Optional[pulumilib.Input[bool]] = None, + github_action_deploy: Optional[pulumilib.Input[bool]] = None, + github_enterprise: Optional[pulumilib.Input['StackGithubEnterpriseArgs']] = None, + gitlab: Optional[pulumilib.Input['StackGitlabArgs']] = None, + import_state: Optional[pulumilib.Input[str]] = None, + import_state_file: Optional[pulumilib.Input[str]] = None, + kubernetes: Optional[pulumilib.Input['StackKubernetesArgs']] = None, + labels: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + manage_state: Optional[pulumilib.Input[bool]] = None, + name: Optional[pulumilib.Input[str]] = None, + project_root: Optional[pulumilib.Input[str]] = None, + protect_from_deletion: Optional[pulumilib.Input[bool]] = None, + pulumi: Optional[pulumilib.Input['StackPulumiArgs']] = None, + raw_git: Optional[pulumilib.Input['StackRawGitArgs']] = None, + repository: Optional[pulumilib.Input[str]] = None, + runner_image: Optional[pulumilib.Input[str]] = None, + showcase: Optional[pulumilib.Input['StackShowcaseArgs']] = None, + slug: Optional[pulumilib.Input[str]] = None, + space_id: Optional[pulumilib.Input[str]] = None, + terraform_external_state_access: Optional[pulumilib.Input[bool]] = None, + terraform_smart_sanitization: Optional[pulumilib.Input[bool]] = None, + terraform_version: Optional[pulumilib.Input[str]] = None, + terraform_workflow_tool: Optional[pulumilib.Input[str]] = None, + terraform_workspace: Optional[pulumilib.Input[str]] = None, + terragrunt: Optional[pulumilib.Input['StackTerragruntArgs']] = None, + worker_pool_id: Optional[pulumilib.Input[str]] = None, + opts: Optional[pulumilib.ResourceOptions] = None, + **kwargs): + if after_applies is None and 'afterApplies' in kwargs: + after_applies = kwargs['afterApplies'] + if after_destroys is None and 'afterDestroys' in kwargs: + after_destroys = kwargs['afterDestroys'] + if after_inits is None and 'afterInits' in kwargs: + after_inits = kwargs['afterInits'] + if after_performs is None and 'afterPerforms' in kwargs: + after_performs = kwargs['afterPerforms'] + if after_plans is None and 'afterPlans' in kwargs: + after_plans = kwargs['afterPlans'] + if after_runs is None and 'afterRuns' in kwargs: + after_runs = kwargs['afterRuns'] + if aws_assume_role_policy_statement is None and 'awsAssumeRolePolicyStatement' in kwargs: + aws_assume_role_policy_statement = kwargs['awsAssumeRolePolicyStatement'] + if azure_devops is None and 'azureDevops' in kwargs: + azure_devops = kwargs['azureDevops'] + if before_applies is None and 'beforeApplies' in kwargs: + before_applies = kwargs['beforeApplies'] + if before_destroys is None and 'beforeDestroys' in kwargs: + before_destroys = kwargs['beforeDestroys'] + if before_inits is None and 'beforeInits' in kwargs: + before_inits = kwargs['beforeInits'] + if before_performs is None and 'beforePerforms' in kwargs: + before_performs = kwargs['beforePerforms'] + if before_plans is None and 'beforePlans' in kwargs: + before_plans = kwargs['beforePlans'] + if bitbucket_cloud is None and 'bitbucketCloud' in kwargs: + bitbucket_cloud = kwargs['bitbucketCloud'] + if bitbucket_datacenter is None and 'bitbucketDatacenter' in kwargs: + bitbucket_datacenter = kwargs['bitbucketDatacenter'] + if enable_local_preview is None and 'enableLocalPreview' in kwargs: + enable_local_preview = kwargs['enableLocalPreview'] + if github_action_deploy is None and 'githubActionDeploy' in kwargs: + github_action_deploy = kwargs['githubActionDeploy'] + if github_enterprise is None and 'githubEnterprise' in kwargs: + github_enterprise = kwargs['githubEnterprise'] + if import_state is None and 'importState' in kwargs: + import_state = kwargs['importState'] + if import_state_file is None and 'importStateFile' in kwargs: + import_state_file = kwargs['importStateFile'] + if manage_state is None and 'manageState' in kwargs: + manage_state = kwargs['manageState'] + if project_root is None and 'projectRoot' in kwargs: + project_root = kwargs['projectRoot'] + if protect_from_deletion is None and 'protectFromDeletion' in kwargs: + protect_from_deletion = kwargs['protectFromDeletion'] + if raw_git is None and 'rawGit' in kwargs: + raw_git = kwargs['rawGit'] + if runner_image is None and 'runnerImage' in kwargs: + runner_image = kwargs['runnerImage'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if terraform_external_state_access is None and 'terraformExternalStateAccess' in kwargs: + terraform_external_state_access = kwargs['terraformExternalStateAccess'] + if terraform_smart_sanitization is None and 'terraformSmartSanitization' in kwargs: + terraform_smart_sanitization = kwargs['terraformSmartSanitization'] + if terraform_version is None and 'terraformVersion' in kwargs: + terraform_version = kwargs['terraformVersion'] + if terraform_workflow_tool is None and 'terraformWorkflowTool' in kwargs: + terraform_workflow_tool = kwargs['terraformWorkflowTool'] + if terraform_workspace is None and 'terraformWorkspace' in kwargs: + terraform_workspace = kwargs['terraformWorkspace'] + if worker_pool_id is None and 'workerPoolId' in kwargs: + worker_pool_id = kwargs['workerPoolId'] + if administrative is not None: - pulumilib.set(__self__, "administrative", administrative) + _setter("administrative", administrative) if after_applies is not None: - pulumilib.set(__self__, "after_applies", after_applies) + _setter("after_applies", after_applies) if after_destroys is not None: - pulumilib.set(__self__, "after_destroys", after_destroys) + _setter("after_destroys", after_destroys) if after_inits is not None: - pulumilib.set(__self__, "after_inits", after_inits) + _setter("after_inits", after_inits) if after_performs is not None: - pulumilib.set(__self__, "after_performs", after_performs) + _setter("after_performs", after_performs) if after_plans is not None: - pulumilib.set(__self__, "after_plans", after_plans) + _setter("after_plans", after_plans) + if after_runs is not None: + _setter("after_runs", after_runs) if ansible is not None: - pulumilib.set(__self__, "ansible", ansible) + _setter("ansible", ansible) if autodeploy is not None: - pulumilib.set(__self__, "autodeploy", autodeploy) + _setter("autodeploy", autodeploy) if autoretry is not None: - pulumilib.set(__self__, "autoretry", autoretry) + _setter("autoretry", autoretry) if aws_assume_role_policy_statement is not None: - pulumilib.set(__self__, "aws_assume_role_policy_statement", aws_assume_role_policy_statement) + _setter("aws_assume_role_policy_statement", aws_assume_role_policy_statement) if azure_devops is not None: - pulumilib.set(__self__, "azure_devops", azure_devops) + _setter("azure_devops", azure_devops) if before_applies is not None: - pulumilib.set(__self__, "before_applies", before_applies) + _setter("before_applies", before_applies) if before_destroys is not None: - pulumilib.set(__self__, "before_destroys", before_destroys) + _setter("before_destroys", before_destroys) if before_inits is not None: - pulumilib.set(__self__, "before_inits", before_inits) + _setter("before_inits", before_inits) if before_performs is not None: - pulumilib.set(__self__, "before_performs", before_performs) + _setter("before_performs", before_performs) if before_plans is not None: - pulumilib.set(__self__, "before_plans", before_plans) + _setter("before_plans", before_plans) if bitbucket_cloud is not None: - pulumilib.set(__self__, "bitbucket_cloud", bitbucket_cloud) + _setter("bitbucket_cloud", bitbucket_cloud) if bitbucket_datacenter is not None: - pulumilib.set(__self__, "bitbucket_datacenter", bitbucket_datacenter) + _setter("bitbucket_datacenter", bitbucket_datacenter) if branch is not None: - pulumilib.set(__self__, "branch", branch) + _setter("branch", branch) if cloudformation is not None: - pulumilib.set(__self__, "cloudformation", cloudformation) + _setter("cloudformation", cloudformation) if description is not None: - pulumilib.set(__self__, "description", description) + _setter("description", description) if enable_local_preview is not None: - pulumilib.set(__self__, "enable_local_preview", enable_local_preview) + _setter("enable_local_preview", enable_local_preview) if github_action_deploy is not None: - pulumilib.set(__self__, "github_action_deploy", github_action_deploy) + _setter("github_action_deploy", github_action_deploy) if github_enterprise is not None: - pulumilib.set(__self__, "github_enterprise", github_enterprise) + _setter("github_enterprise", github_enterprise) if gitlab is not None: - pulumilib.set(__self__, "gitlab", gitlab) + _setter("gitlab", gitlab) if import_state is not None: - pulumilib.set(__self__, "import_state", import_state) + _setter("import_state", import_state) if import_state_file is not None: - pulumilib.set(__self__, "import_state_file", import_state_file) + _setter("import_state_file", import_state_file) if kubernetes is not None: - pulumilib.set(__self__, "kubernetes", kubernetes) + _setter("kubernetes", kubernetes) if labels is not None: - pulumilib.set(__self__, "labels", labels) + _setter("labels", labels) if manage_state is not None: - pulumilib.set(__self__, "manage_state", manage_state) + _setter("manage_state", manage_state) if name is not None: - pulumilib.set(__self__, "name", name) + _setter("name", name) if project_root is not None: - pulumilib.set(__self__, "project_root", project_root) + _setter("project_root", project_root) if protect_from_deletion is not None: - pulumilib.set(__self__, "protect_from_deletion", protect_from_deletion) + _setter("protect_from_deletion", protect_from_deletion) if pulumi is not None: - pulumilib.set(__self__, "pulumi", pulumi) + _setter("pulumi", pulumi) + if raw_git is not None: + _setter("raw_git", raw_git) if repository is not None: - pulumilib.set(__self__, "repository", repository) + _setter("repository", repository) if runner_image is not None: - pulumilib.set(__self__, "runner_image", runner_image) + _setter("runner_image", runner_image) if showcase is not None: - pulumilib.set(__self__, "showcase", showcase) + _setter("showcase", showcase) if slug is not None: - pulumilib.set(__self__, "slug", slug) + _setter("slug", slug) if space_id is not None: - pulumilib.set(__self__, "space_id", space_id) + _setter("space_id", space_id) + if terraform_external_state_access is not None: + _setter("terraform_external_state_access", terraform_external_state_access) if terraform_smart_sanitization is not None: - pulumilib.set(__self__, "terraform_smart_sanitization", terraform_smart_sanitization) + _setter("terraform_smart_sanitization", terraform_smart_sanitization) if terraform_version is not None: - pulumilib.set(__self__, "terraform_version", terraform_version) + _setter("terraform_version", terraform_version) + if terraform_workflow_tool is not None: + _setter("terraform_workflow_tool", terraform_workflow_tool) if terraform_workspace is not None: - pulumilib.set(__self__, "terraform_workspace", terraform_workspace) + _setter("terraform_workspace", terraform_workspace) + if terragrunt is not None: + _setter("terragrunt", terragrunt) if worker_pool_id is not None: - pulumilib.set(__self__, "worker_pool_id", worker_pool_id) + _setter("worker_pool_id", worker_pool_id) @property @pulumilib.getter @@ -938,6 +1376,18 @@ def after_plans(self) -> Optional[pulumilib.Input[Sequence[pulumilib.Input[str]] def after_plans(self, value: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]]): pulumilib.set(self, "after_plans", value) + @property + @pulumilib.getter(name="afterRuns") + def after_runs(self) -> Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]]: + """ + List of after-run scripts + """ + return pulumilib.get(self, "after_runs") + + @after_runs.setter + def after_runs(self, value: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]]): + pulumilib.set(self, "after_runs", value) + @property @pulumilib.getter def ansible(self) -> Optional[pulumilib.Input['StackAnsibleArgs']]: @@ -1134,7 +1584,7 @@ def enable_local_preview(self, value: Optional[pulumilib.Input[bool]]): @pulumilib.getter(name="githubActionDeploy") def github_action_deploy(self) -> Optional[pulumilib.Input[bool]]: """ - Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. """ return pulumilib.get(self, "github_action_deploy") @@ -1146,7 +1596,7 @@ def github_action_deploy(self, value: Optional[pulumilib.Input[bool]]): @pulumilib.getter(name="githubEnterprise") def github_enterprise(self) -> Optional[pulumilib.Input['StackGithubEnterpriseArgs']]: """ - GitHub Enterprise (self-hosted) VCS settings + VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) """ return pulumilib.get(self, "github_enterprise") @@ -1271,6 +1721,18 @@ def pulumi(self) -> Optional[pulumilib.Input['StackPulumiArgs']]: def pulumi(self, value: Optional[pulumilib.Input['StackPulumiArgs']]): pulumilib.set(self, "pulumi", value) + @property + @pulumilib.getter(name="rawGit") + def raw_git(self) -> Optional[pulumilib.Input['StackRawGitArgs']]: + """ + One-way VCS integration using a raw Git repository link + """ + return pulumilib.get(self, "raw_git") + + @raw_git.setter + def raw_git(self, value: Optional[pulumilib.Input['StackRawGitArgs']]): + pulumilib.set(self, "raw_git", value) + @property @pulumilib.getter def repository(self) -> Optional[pulumilib.Input[str]]: @@ -1320,7 +1782,7 @@ def slug(self, value: Optional[pulumilib.Input[str]]): @pulumilib.getter(name="spaceId") def space_id(self) -> Optional[pulumilib.Input[str]]: """ - ID (slug) of the space the stack is in + ID (slug) of the space the stack is in. Defaults to `legacy`. """ return pulumilib.get(self, "space_id") @@ -1328,6 +1790,18 @@ def space_id(self) -> Optional[pulumilib.Input[str]]: def space_id(self, value: Optional[pulumilib.Input[str]]): pulumilib.set(self, "space_id", value) + @property + @pulumilib.getter(name="terraformExternalStateAccess") + def terraform_external_state_access(self) -> Optional[pulumilib.Input[bool]]: + """ + Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + """ + return pulumilib.get(self, "terraform_external_state_access") + + @terraform_external_state_access.setter + def terraform_external_state_access(self, value: Optional[pulumilib.Input[bool]]): + pulumilib.set(self, "terraform_external_state_access", value) + @property @pulumilib.getter(name="terraformSmartSanitization") def terraform_smart_sanitization(self) -> Optional[pulumilib.Input[bool]]: @@ -1354,6 +1828,18 @@ def terraform_version(self) -> Optional[pulumilib.Input[str]]: def terraform_version(self, value: Optional[pulumilib.Input[str]]): pulumilib.set(self, "terraform_version", value) + @property + @pulumilib.getter(name="terraformWorkflowTool") + def terraform_workflow_tool(self) -> Optional[pulumilib.Input[str]]: + """ + Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + """ + return pulumilib.get(self, "terraform_workflow_tool") + + @terraform_workflow_tool.setter + def terraform_workflow_tool(self, value: Optional[pulumilib.Input[str]]): + pulumilib.set(self, "terraform_workflow_tool", value) + @property @pulumilib.getter(name="terraformWorkspace") def terraform_workspace(self) -> Optional[pulumilib.Input[str]]: @@ -1366,11 +1852,23 @@ def terraform_workspace(self) -> Optional[pulumilib.Input[str]]: def terraform_workspace(self, value: Optional[pulumilib.Input[str]]): pulumilib.set(self, "terraform_workspace", value) + @property + @pulumilib.getter + def terragrunt(self) -> Optional[pulumilib.Input['StackTerragruntArgs']]: + """ + Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + """ + return pulumilib.get(self, "terragrunt") + + @terragrunt.setter + def terragrunt(self, value: Optional[pulumilib.Input['StackTerragruntArgs']]): + pulumilib.set(self, "terragrunt", value) + @property @pulumilib.getter(name="workerPoolId") def worker_pool_id(self) -> Optional[pulumilib.Input[str]]: """ - ID of the worker pool to use + ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. """ return pulumilib.get(self, "worker_pool_id") @@ -1390,6 +1888,7 @@ def __init__(__self__, after_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_runs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, ansible: Optional[pulumilib.Input[pulumilib.InputType['StackAnsibleArgs']]] = None, autodeploy: Optional[pulumilib.Input[bool]] = None, autoretry: Optional[pulumilib.Input[bool]] = None, @@ -1417,14 +1916,18 @@ def __init__(__self__, project_root: Optional[pulumilib.Input[str]] = None, protect_from_deletion: Optional[pulumilib.Input[bool]] = None, pulumi: Optional[pulumilib.Input[pulumilib.InputType['StackPulumiArgs']]] = None, + raw_git: Optional[pulumilib.Input[pulumilib.InputType['StackRawGitArgs']]] = None, repository: Optional[pulumilib.Input[str]] = None, runner_image: Optional[pulumilib.Input[str]] = None, showcase: Optional[pulumilib.Input[pulumilib.InputType['StackShowcaseArgs']]] = None, slug: Optional[pulumilib.Input[str]] = None, space_id: Optional[pulumilib.Input[str]] = None, + terraform_external_state_access: Optional[pulumilib.Input[bool]] = None, terraform_smart_sanitization: Optional[pulumilib.Input[bool]] = None, terraform_version: Optional[pulumilib.Input[str]] = None, + terraform_workflow_tool: Optional[pulumilib.Input[str]] = None, terraform_workspace: Optional[pulumilib.Input[str]] = None, + terragrunt: Optional[pulumilib.Input[pulumilib.InputType['StackTerragruntArgs']]] = None, worker_pool_id: Optional[pulumilib.Input[str]] = None, __props__=None): """ @@ -1447,7 +1950,7 @@ def __init__(__self__, description="Provisions a Kubernetes cluster", project_root="cluster", repository="core-infra", - terraform_version="0.12.6") + terraform_version="1.3.0") # Terraform stack using Bitbucket Data Center as VCS k8s_cluster_bitbucket_datacenter = spacelift.Stack("k8s-cluster-bitbucket-datacenter", administrative=True, @@ -1459,8 +1962,8 @@ def __init__(__self__, description="Provisions a Kubernetes cluster", project_root="cluster", repository="core-infra", - terraform_version="0.12.6") - # Terraform stack using GitHub Enterprise as VCS + terraform_version="1.3.0") + # Terraform stack using a GitHub Custom Application. See the following page for more info: https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application k8s_cluster_github_enterprise = spacelift.Stack("k8s-cluster-github-enterprise", administrative=True, autodeploy=True, @@ -1471,7 +1974,7 @@ def __init__(__self__, ), project_root="cluster", repository="core-infra", - terraform_version="0.12.6") + terraform_version="1.3.0") # Terraform stack using GitLab as VCS k8s_cluster_gitlab = spacelift.Stack("k8s-cluster-gitlab", administrative=True, @@ -1483,8 +1986,8 @@ def __init__(__self__, ), project_root="cluster", repository="core-infra", - terraform_version="0.12.6") - # Terraform stack using github.com as VCS and enabling smart sanitization + terraform_version="1.3.0") + # Terraform stack using github.com as VCS and enabling external state access k8s_cluster = spacelift.Stack("k8s-cluster", administrative=True, autodeploy=True, @@ -1492,8 +1995,8 @@ def __init__(__self__, description="Provisions a Kubernetes cluster", project_root="cluster", repository="core-infra", - terraform_smart_sanitization=True, - terraform_version="1.2.6") + terraform_external_state_access=True, + terraform_version="1.3.0") # CloudFormation stack using github.com as VCS k8s_cluster_cloudformation = spacelift.Stack("k8s-cluster-cloudformation", autodeploy=True, @@ -1526,6 +2029,7 @@ def __init__(__self__, branch="master", description="Shared cluster services (Datadog, Istio etc.)", kubernetes=spacelift.StackKubernetesArgs( + kubectl_version="1.26.1", namespace="core", ), project_root="core-services", @@ -1556,6 +2060,7 @@ def __init__(__self__, :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_inits: List of after-init scripts :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_performs: List of after-perform scripts :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_plans: List of after-plan scripts + :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_runs: List of after-run scripts :param pulumilib.Input[pulumilib.InputType['StackAnsibleArgs']] ansible: Ansible-specific configuration. Presence means this Stack is an Ansible Stack. :param pulumilib.Input[bool] autodeploy: Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. :param pulumilib.Input[bool] autoretry: Indicates whether obsolete proposed changes should automatically be retried. Defaults to `false`. @@ -1571,8 +2076,8 @@ def __init__(__self__, :param pulumilib.Input[pulumilib.InputType['StackCloudformationArgs']] cloudformation: CloudFormation-specific configuration. Presence means this Stack is a CloudFormation Stack. :param pulumilib.Input[str] description: Free-form stack description for users :param pulumilib.Input[bool] enable_local_preview: Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. - :param pulumilib.Input[bool] github_action_deploy: Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. - :param pulumilib.Input[pulumilib.InputType['StackGithubEnterpriseArgs']] github_enterprise: GitHub Enterprise (self-hosted) VCS settings + :param pulumilib.Input[bool] github_action_deploy: Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. + :param pulumilib.Input[pulumilib.InputType['StackGithubEnterpriseArgs']] github_enterprise: VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) :param pulumilib.Input[pulumilib.InputType['StackGitlabArgs']] gitlab: GitLab VCS settings :param pulumilib.Input[str] import_state: State file to upload when creating a new stack :param pulumilib.Input[str] import_state_file: Path to the state file to upload when creating a new stack @@ -1582,16 +2087,20 @@ def __init__(__self__, :param pulumilib.Input[str] project_root: Project root is the optional directory relative to the workspace root containing the entrypoint to the Stack. :param pulumilib.Input[bool] protect_from_deletion: Protect this stack from accidental deletion. If set, attempts to delete this stack will fail. Defaults to `false`. :param pulumilib.Input[pulumilib.InputType['StackPulumiArgs']] pulumi: Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. + :param pulumilib.Input[pulumilib.InputType['StackRawGitArgs']] raw_git: One-way VCS integration using a raw Git repository link :param pulumilib.Input[str] repository: Name of the repository, without the owner part :param pulumilib.Input[str] runner_image: Name of the Docker image used to process Runs :param pulumilib.Input[str] slug: Allows setting the custom ID (slug) for the stack - :param pulumilib.Input[str] space_id: ID (slug) of the space the stack is in + :param pulumilib.Input[str] space_id: ID (slug) of the space the stack is in. Defaults to `legacy`. + :param pulumilib.Input[bool] terraform_external_state_access: Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. :param pulumilib.Input[bool] terraform_smart_sanitization: Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. Defaults to `false`. :param pulumilib.Input[str] terraform_version: Terraform version to use + :param pulumilib.Input[str] terraform_workflow_tool: Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. :param pulumilib.Input[str] terraform_workspace: Terraform workspace to select - :param pulumilib.Input[str] worker_pool_id: ID of the worker pool to use + :param pulumilib.Input[pulumilib.InputType['StackTerragruntArgs']] terragrunt: Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + :param pulumilib.Input[str] worker_pool_id: ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. """ ... @overload @@ -1619,7 +2128,7 @@ def __init__(__self__, description="Provisions a Kubernetes cluster", project_root="cluster", repository="core-infra", - terraform_version="0.12.6") + terraform_version="1.3.0") # Terraform stack using Bitbucket Data Center as VCS k8s_cluster_bitbucket_datacenter = spacelift.Stack("k8s-cluster-bitbucket-datacenter", administrative=True, @@ -1631,8 +2140,8 @@ def __init__(__self__, description="Provisions a Kubernetes cluster", project_root="cluster", repository="core-infra", - terraform_version="0.12.6") - # Terraform stack using GitHub Enterprise as VCS + terraform_version="1.3.0") + # Terraform stack using a GitHub Custom Application. See the following page for more info: https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application k8s_cluster_github_enterprise = spacelift.Stack("k8s-cluster-github-enterprise", administrative=True, autodeploy=True, @@ -1643,7 +2152,7 @@ def __init__(__self__, ), project_root="cluster", repository="core-infra", - terraform_version="0.12.6") + terraform_version="1.3.0") # Terraform stack using GitLab as VCS k8s_cluster_gitlab = spacelift.Stack("k8s-cluster-gitlab", administrative=True, @@ -1655,8 +2164,8 @@ def __init__(__self__, ), project_root="cluster", repository="core-infra", - terraform_version="0.12.6") - # Terraform stack using github.com as VCS and enabling smart sanitization + terraform_version="1.3.0") + # Terraform stack using github.com as VCS and enabling external state access k8s_cluster = spacelift.Stack("k8s-cluster", administrative=True, autodeploy=True, @@ -1664,8 +2173,8 @@ def __init__(__self__, description="Provisions a Kubernetes cluster", project_root="cluster", repository="core-infra", - terraform_smart_sanitization=True, - terraform_version="1.2.6") + terraform_external_state_access=True, + terraform_version="1.3.0") # CloudFormation stack using github.com as VCS k8s_cluster_cloudformation = spacelift.Stack("k8s-cluster-cloudformation", autodeploy=True, @@ -1698,6 +2207,7 @@ def __init__(__self__, branch="master", description="Shared cluster services (Datadog, Istio etc.)", kubernetes=spacelift.StackKubernetesArgs( + kubectl_version="1.26.1", namespace="core", ), project_root="core-services", @@ -1730,6 +2240,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + StackArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -1741,6 +2255,7 @@ def _internal_init(__self__, after_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_runs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, ansible: Optional[pulumilib.Input[pulumilib.InputType['StackAnsibleArgs']]] = None, autodeploy: Optional[pulumilib.Input[bool]] = None, autoretry: Optional[pulumilib.Input[bool]] = None, @@ -1768,14 +2283,18 @@ def _internal_init(__self__, project_root: Optional[pulumilib.Input[str]] = None, protect_from_deletion: Optional[pulumilib.Input[bool]] = None, pulumi: Optional[pulumilib.Input[pulumilib.InputType['StackPulumiArgs']]] = None, + raw_git: Optional[pulumilib.Input[pulumilib.InputType['StackRawGitArgs']]] = None, repository: Optional[pulumilib.Input[str]] = None, runner_image: Optional[pulumilib.Input[str]] = None, showcase: Optional[pulumilib.Input[pulumilib.InputType['StackShowcaseArgs']]] = None, slug: Optional[pulumilib.Input[str]] = None, space_id: Optional[pulumilib.Input[str]] = None, + terraform_external_state_access: Optional[pulumilib.Input[bool]] = None, terraform_smart_sanitization: Optional[pulumilib.Input[bool]] = None, terraform_version: Optional[pulumilib.Input[str]] = None, + terraform_workflow_tool: Optional[pulumilib.Input[str]] = None, terraform_workspace: Optional[pulumilib.Input[str]] = None, + terragrunt: Optional[pulumilib.Input[pulumilib.InputType['StackTerragruntArgs']]] = None, worker_pool_id: Optional[pulumilib.Input[str]] = None, __props__=None): opts = pulumilib.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) @@ -1792,47 +2311,66 @@ def _internal_init(__self__, __props__.__dict__["after_inits"] = after_inits __props__.__dict__["after_performs"] = after_performs __props__.__dict__["after_plans"] = after_plans + __props__.__dict__["after_runs"] = after_runs + ansible = _utilities.configure(ansible, StackAnsibleArgs, True) __props__.__dict__["ansible"] = ansible __props__.__dict__["autodeploy"] = autodeploy __props__.__dict__["autoretry"] = autoretry + azure_devops = _utilities.configure(azure_devops, StackAzureDevopsArgs, True) __props__.__dict__["azure_devops"] = azure_devops __props__.__dict__["before_applies"] = before_applies __props__.__dict__["before_destroys"] = before_destroys __props__.__dict__["before_inits"] = before_inits __props__.__dict__["before_performs"] = before_performs __props__.__dict__["before_plans"] = before_plans + bitbucket_cloud = _utilities.configure(bitbucket_cloud, StackBitbucketCloudArgs, True) __props__.__dict__["bitbucket_cloud"] = bitbucket_cloud + bitbucket_datacenter = _utilities.configure(bitbucket_datacenter, StackBitbucketDatacenterArgs, True) __props__.__dict__["bitbucket_datacenter"] = bitbucket_datacenter if branch is None and not opts.urn: raise TypeError("Missing required property 'branch'") __props__.__dict__["branch"] = branch + cloudformation = _utilities.configure(cloudformation, StackCloudformationArgs, True) __props__.__dict__["cloudformation"] = cloudformation __props__.__dict__["description"] = description __props__.__dict__["enable_local_preview"] = enable_local_preview __props__.__dict__["github_action_deploy"] = github_action_deploy + github_enterprise = _utilities.configure(github_enterprise, StackGithubEnterpriseArgs, True) __props__.__dict__["github_enterprise"] = github_enterprise + gitlab = _utilities.configure(gitlab, StackGitlabArgs, True) __props__.__dict__["gitlab"] = gitlab - __props__.__dict__["import_state"] = import_state + __props__.__dict__["import_state"] = None if import_state is None else pulumilib.Output.secret(import_state) __props__.__dict__["import_state_file"] = import_state_file + kubernetes = _utilities.configure(kubernetes, StackKubernetesArgs, True) __props__.__dict__["kubernetes"] = kubernetes __props__.__dict__["labels"] = labels __props__.__dict__["manage_state"] = manage_state __props__.__dict__["name"] = name __props__.__dict__["project_root"] = project_root __props__.__dict__["protect_from_deletion"] = protect_from_deletion + pulumi = _utilities.configure(pulumi, StackPulumiArgs, True) __props__.__dict__["pulumi"] = pulumi + raw_git = _utilities.configure(raw_git, StackRawGitArgs, True) + __props__.__dict__["raw_git"] = raw_git if repository is None and not opts.urn: raise TypeError("Missing required property 'repository'") __props__.__dict__["repository"] = repository __props__.__dict__["runner_image"] = runner_image + showcase = _utilities.configure(showcase, StackShowcaseArgs, True) __props__.__dict__["showcase"] = showcase __props__.__dict__["slug"] = slug __props__.__dict__["space_id"] = space_id + __props__.__dict__["terraform_external_state_access"] = terraform_external_state_access __props__.__dict__["terraform_smart_sanitization"] = terraform_smart_sanitization __props__.__dict__["terraform_version"] = terraform_version + __props__.__dict__["terraform_workflow_tool"] = terraform_workflow_tool __props__.__dict__["terraform_workspace"] = terraform_workspace + terragrunt = _utilities.configure(terragrunt, StackTerragruntArgs, True) + __props__.__dict__["terragrunt"] = terragrunt __props__.__dict__["worker_pool_id"] = worker_pool_id __props__.__dict__["aws_assume_role_policy_statement"] = None + secret_opts = pulumilib.ResourceOptions(additional_secret_outputs=["importState"]) + opts = pulumilib.ResourceOptions.merge(opts, secret_opts) super(Stack, __self__).__init__( 'spacelift:index/stack:Stack', resource_name, @@ -1849,6 +2387,7 @@ def get(resource_name: str, after_inits: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_performs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, after_plans: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, + after_runs: Optional[pulumilib.Input[Sequence[pulumilib.Input[str]]]] = None, ansible: Optional[pulumilib.Input[pulumilib.InputType['StackAnsibleArgs']]] = None, autodeploy: Optional[pulumilib.Input[bool]] = None, autoretry: Optional[pulumilib.Input[bool]] = None, @@ -1877,14 +2416,18 @@ def get(resource_name: str, project_root: Optional[pulumilib.Input[str]] = None, protect_from_deletion: Optional[pulumilib.Input[bool]] = None, pulumi: Optional[pulumilib.Input[pulumilib.InputType['StackPulumiArgs']]] = None, + raw_git: Optional[pulumilib.Input[pulumilib.InputType['StackRawGitArgs']]] = None, repository: Optional[pulumilib.Input[str]] = None, runner_image: Optional[pulumilib.Input[str]] = None, showcase: Optional[pulumilib.Input[pulumilib.InputType['StackShowcaseArgs']]] = None, slug: Optional[pulumilib.Input[str]] = None, space_id: Optional[pulumilib.Input[str]] = None, + terraform_external_state_access: Optional[pulumilib.Input[bool]] = None, terraform_smart_sanitization: Optional[pulumilib.Input[bool]] = None, terraform_version: Optional[pulumilib.Input[str]] = None, + terraform_workflow_tool: Optional[pulumilib.Input[str]] = None, terraform_workspace: Optional[pulumilib.Input[str]] = None, + terragrunt: Optional[pulumilib.Input[pulumilib.InputType['StackTerragruntArgs']]] = None, worker_pool_id: Optional[pulumilib.Input[str]] = None) -> 'Stack': """ Get an existing Stack resource's state with the given name, id, and optional extra @@ -1899,6 +2442,7 @@ def get(resource_name: str, :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_inits: List of after-init scripts :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_performs: List of after-perform scripts :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_plans: List of after-plan scripts + :param pulumilib.Input[Sequence[pulumilib.Input[str]]] after_runs: List of after-run scripts :param pulumilib.Input[pulumilib.InputType['StackAnsibleArgs']] ansible: Ansible-specific configuration. Presence means this Stack is an Ansible Stack. :param pulumilib.Input[bool] autodeploy: Indicates whether changes to this stack can be automatically deployed. Defaults to `false`. :param pulumilib.Input[bool] autoretry: Indicates whether obsolete proposed changes should automatically be retried. Defaults to `false`. @@ -1915,8 +2459,8 @@ def get(resource_name: str, :param pulumilib.Input[pulumilib.InputType['StackCloudformationArgs']] cloudformation: CloudFormation-specific configuration. Presence means this Stack is a CloudFormation Stack. :param pulumilib.Input[str] description: Free-form stack description for users :param pulumilib.Input[bool] enable_local_preview: Indicates whether local preview runs can be triggered on this Stack. Defaults to `false`. - :param pulumilib.Input[bool] github_action_deploy: Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. - :param pulumilib.Input[pulumilib.InputType['StackGithubEnterpriseArgs']] github_enterprise: GitHub Enterprise (self-hosted) VCS settings + :param pulumilib.Input[bool] github_action_deploy: Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. + :param pulumilib.Input[pulumilib.InputType['StackGithubEnterpriseArgs']] github_enterprise: VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) :param pulumilib.Input[pulumilib.InputType['StackGitlabArgs']] gitlab: GitLab VCS settings :param pulumilib.Input[str] import_state: State file to upload when creating a new stack :param pulumilib.Input[str] import_state_file: Path to the state file to upload when creating a new stack @@ -1926,16 +2470,20 @@ def get(resource_name: str, :param pulumilib.Input[str] project_root: Project root is the optional directory relative to the workspace root containing the entrypoint to the Stack. :param pulumilib.Input[bool] protect_from_deletion: Protect this stack from accidental deletion. If set, attempts to delete this stack will fail. Defaults to `false`. :param pulumilib.Input[pulumilib.InputType['StackPulumiArgs']] pulumi: Pulumi-specific configuration. Presence means this Stack is a Pulumi Stack. + :param pulumilib.Input[pulumilib.InputType['StackRawGitArgs']] raw_git: One-way VCS integration using a raw Git repository link :param pulumilib.Input[str] repository: Name of the repository, without the owner part :param pulumilib.Input[str] runner_image: Name of the Docker image used to process Runs :param pulumilib.Input[str] slug: Allows setting the custom ID (slug) for the stack - :param pulumilib.Input[str] space_id: ID (slug) of the space the stack is in + :param pulumilib.Input[str] space_id: ID (slug) of the space the stack is in. Defaults to `legacy`. + :param pulumilib.Input[bool] terraform_external_state_access: Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. :param pulumilib.Input[bool] terraform_smart_sanitization: Indicates whether runs on this will use terraform's sensitive value system to sanitize the outputs of Terraform state and plans in spacelift instead of sanitizing all fields. Note: Requires the terraform version to be v1.0.1 or above. Defaults to `false`. :param pulumilib.Input[str] terraform_version: Terraform version to use + :param pulumilib.Input[str] terraform_workflow_tool: Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. :param pulumilib.Input[str] terraform_workspace: Terraform workspace to select - :param pulumilib.Input[str] worker_pool_id: ID of the worker pool to use + :param pulumilib.Input[pulumilib.InputType['StackTerragruntArgs']] terragrunt: Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + :param pulumilib.Input[str] worker_pool_id: ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. """ opts = pulumilib.ResourceOptions.merge(opts, pulumilib.ResourceOptions(id=id)) @@ -1947,6 +2495,7 @@ def get(resource_name: str, __props__.__dict__["after_inits"] = after_inits __props__.__dict__["after_performs"] = after_performs __props__.__dict__["after_plans"] = after_plans + __props__.__dict__["after_runs"] = after_runs __props__.__dict__["ansible"] = ansible __props__.__dict__["autodeploy"] = autodeploy __props__.__dict__["autoretry"] = autoretry @@ -1975,14 +2524,18 @@ def get(resource_name: str, __props__.__dict__["project_root"] = project_root __props__.__dict__["protect_from_deletion"] = protect_from_deletion __props__.__dict__["pulumi"] = pulumi + __props__.__dict__["raw_git"] = raw_git __props__.__dict__["repository"] = repository __props__.__dict__["runner_image"] = runner_image __props__.__dict__["showcase"] = showcase __props__.__dict__["slug"] = slug __props__.__dict__["space_id"] = space_id + __props__.__dict__["terraform_external_state_access"] = terraform_external_state_access __props__.__dict__["terraform_smart_sanitization"] = terraform_smart_sanitization __props__.__dict__["terraform_version"] = terraform_version + __props__.__dict__["terraform_workflow_tool"] = terraform_workflow_tool __props__.__dict__["terraform_workspace"] = terraform_workspace + __props__.__dict__["terragrunt"] = terragrunt __props__.__dict__["worker_pool_id"] = worker_pool_id return Stack(resource_name, opts=opts, __props__=__props__) @@ -2034,6 +2587,14 @@ def after_plans(self) -> pulumilib.Output[Optional[Sequence[str]]]: """ return pulumilib.get(self, "after_plans") + @property + @pulumilib.getter(name="afterRuns") + def after_runs(self) -> pulumilib.Output[Optional[Sequence[str]]]: + """ + List of after-run scripts + """ + return pulumilib.get(self, "after_runs") + @property @pulumilib.getter def ansible(self) -> pulumilib.Output[Optional['outputs.StackAnsible']]: @@ -2166,7 +2727,7 @@ def enable_local_preview(self) -> pulumilib.Output[Optional[bool]]: @pulumilib.getter(name="githubActionDeploy") def github_action_deploy(self) -> pulumilib.Output[Optional[bool]]: """ - Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. + Indicates whether GitHub users can deploy from the Checks API. Defaults to `true`. This is called allow run promotion in the UI. """ return pulumilib.get(self, "github_action_deploy") @@ -2174,7 +2735,7 @@ def github_action_deploy(self) -> pulumilib.Output[Optional[bool]]: @pulumilib.getter(name="githubEnterprise") def github_enterprise(self) -> pulumilib.Output[Optional['outputs.StackGithubEnterprise']]: """ - GitHub Enterprise (self-hosted) VCS settings + VCS settings for [GitHub custom application](https://docs.spacelift.io/integrations/source-control/github#setting-up-the-custom-application) """ return pulumilib.get(self, "github_enterprise") @@ -2255,6 +2816,14 @@ def pulumi(self) -> pulumilib.Output[Optional['outputs.StackPulumi']]: """ return pulumilib.get(self, "pulumi") + @property + @pulumilib.getter(name="rawGit") + def raw_git(self) -> pulumilib.Output[Optional['outputs.StackRawGit']]: + """ + One-way VCS integration using a raw Git repository link + """ + return pulumilib.get(self, "raw_git") + @property @pulumilib.getter def repository(self) -> pulumilib.Output[str]: @@ -2288,10 +2857,18 @@ def slug(self) -> pulumilib.Output[str]: @pulumilib.getter(name="spaceId") def space_id(self) -> pulumilib.Output[str]: """ - ID (slug) of the space the stack is in + ID (slug) of the space the stack is in. Defaults to `legacy`. """ return pulumilib.get(self, "space_id") + @property + @pulumilib.getter(name="terraformExternalStateAccess") + def terraform_external_state_access(self) -> pulumilib.Output[Optional[bool]]: + """ + Indicates whether you can access the Stack state file from other stacks or outside of Spacelift. Defaults to `false`. + """ + return pulumilib.get(self, "terraform_external_state_access") + @property @pulumilib.getter(name="terraformSmartSanitization") def terraform_smart_sanitization(self) -> pulumilib.Output[Optional[bool]]: @@ -2310,6 +2887,14 @@ def terraform_version(self) -> pulumilib.Output[Optional[str]]: """ return pulumilib.get(self, "terraform_version") + @property + @pulumilib.getter(name="terraformWorkflowTool") + def terraform_workflow_tool(self) -> pulumilib.Output[str]: + """ + Defines the tool that will be used to execute the workflow. This can be one of `OPEN_TOFU`, `TERRAFORM_FOSS` or `CUSTOM`. Defaults to `TERRAFORM_FOSS`. + """ + return pulumilib.get(self, "terraform_workflow_tool") + @property @pulumilib.getter(name="terraformWorkspace") def terraform_workspace(self) -> pulumilib.Output[Optional[str]]: @@ -2318,11 +2903,19 @@ def terraform_workspace(self) -> pulumilib.Output[Optional[str]]: """ return pulumilib.get(self, "terraform_workspace") + @property + @pulumilib.getter + def terragrunt(self) -> pulumilib.Output[Optional['outputs.StackTerragrunt']]: + """ + Terragrunt-specific configuration. Presence means this Stack is an Terragrunt Stack. + """ + return pulumilib.get(self, "terragrunt") + @property @pulumilib.getter(name="workerPoolId") def worker_pool_id(self) -> pulumilib.Output[Optional[str]]: """ - ID of the worker pool to use + ID of the worker pool to use. NOTE: worker*pool*id is required when using a self-hosted instance of Spacelift. """ return pulumilib.get(self, "worker_pool_id") diff --git a/sdk/python/pulumi_spacelift/stack_activator.py b/sdk/python/pulumi_spacelift/stack_activator.py new file mode 100644 index 0000000..3782419 --- /dev/null +++ b/sdk/python/pulumi_spacelift/stack_activator.py @@ -0,0 +1,260 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['StackActivatorArgs', 'StackActivator'] + +@pulumi.input_type +class StackActivatorArgs: + def __init__(__self__, *, + enabled: pulumi.Input[bool], + stack_id: pulumi.Input[str]): + """ + The set of arguments for constructing a StackActivator resource. + :param pulumi.Input[bool] enabled: Enable/disable stack + :param pulumi.Input[str] stack_id: ID of the stack to enable/disable + """ + StackActivatorArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + enabled=enabled, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + enabled: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if enabled is None: + raise TypeError("Missing 'enabled' argument") + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if stack_id is None: + raise TypeError("Missing 'stack_id' argument") + + _setter("enabled", enabled) + _setter("stack_id", stack_id) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Input[bool]: + """ + Enable/disable stack + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: pulumi.Input[bool]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> pulumi.Input[str]: + """ + ID of the stack to enable/disable + """ + return pulumi.get(self, "stack_id") + + @stack_id.setter + def stack_id(self, value: pulumi.Input[str]): + pulumi.set(self, "stack_id", value) + + +@pulumi.input_type +class _StackActivatorState: + def __init__(__self__, *, + enabled: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering StackActivator resources. + :param pulumi.Input[bool] enabled: Enable/disable stack + :param pulumi.Input[str] stack_id: ID of the stack to enable/disable + """ + _StackActivatorState._configure( + lambda key, value: pulumi.set(__self__, key, value), + enabled=enabled, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + enabled: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + if enabled is not None: + _setter("enabled", enabled) + if stack_id is not None: + _setter("stack_id", stack_id) + + @property + @pulumi.getter + def enabled(self) -> Optional[pulumi.Input[bool]]: + """ + Enable/disable stack + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the stack to enable/disable + """ + return pulumi.get(self, "stack_id") + + @stack_id.setter + def stack_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "stack_id", value) + + +class StackActivator(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `StackActivator` is used to to enable/disable Spacelift Stack. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + app = spacelift.Stack("app", + branch="master", + repository="app") + test = spacelift.StackActivator("test", + enabled=True, + stack_id=app.id) + ``` + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[bool] enabled: Enable/disable stack + :param pulumi.Input[str] stack_id: ID of the stack to enable/disable + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: StackActivatorArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `StackActivator` is used to to enable/disable Spacelift Stack. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + app = spacelift.Stack("app", + branch="master", + repository="app") + test = spacelift.StackActivator("test", + enabled=True, + stack_id=app.id) + ``` + + :param str resource_name: The name of the resource. + :param StackActivatorArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(StackActivatorArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + StackActivatorArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = StackActivatorArgs.__new__(StackActivatorArgs) + + if enabled is None and not opts.urn: + raise TypeError("Missing required property 'enabled'") + __props__.__dict__["enabled"] = enabled + if stack_id is None and not opts.urn: + raise TypeError("Missing required property 'stack_id'") + __props__.__dict__["stack_id"] = stack_id + super(StackActivator, __self__).__init__( + 'spacelift:index/stackActivator:StackActivator', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None) -> 'StackActivator': + """ + Get an existing StackActivator resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[bool] enabled: Enable/disable stack + :param pulumi.Input[str] stack_id: ID of the stack to enable/disable + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _StackActivatorState.__new__(_StackActivatorState) + + __props__.__dict__["enabled"] = enabled + __props__.__dict__["stack_id"] = stack_id + return StackActivator(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Output[bool]: + """ + Enable/disable stack + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> pulumi.Output[str]: + """ + ID of the stack to enable/disable + """ + return pulumi.get(self, "stack_id") + diff --git a/sdk/python/pulumi_spacelift/stack_aws_role.py b/sdk/python/pulumi_spacelift/stack_aws_role.py index b97fb14..66b57db 100644 --- a/sdk/python/pulumi_spacelift/stack_aws_role.py +++ b/sdk/python/pulumi_spacelift/stack_aws_role.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['StackAwsRoleArgs', 'StackAwsRole'] @@ -29,17 +29,52 @@ def __init__(__self__, *, :param pulumi.Input[str] module_id: ID of the module which assumes the AWS IAM role :param pulumi.Input[str] stack_id: ID of the stack which assumes the AWS IAM role """ - pulumi.set(__self__, "role_arn", role_arn) + StackAwsRoleArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + role_arn=role_arn, + duration_seconds=duration_seconds, + external_id=external_id, + generate_credentials_in_worker=generate_credentials_in_worker, + module_id=module_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + role_arn: Optional[pulumi.Input[str]] = None, + duration_seconds: Optional[pulumi.Input[int]] = None, + external_id: Optional[pulumi.Input[str]] = None, + generate_credentials_in_worker: Optional[pulumi.Input[bool]] = None, + module_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if role_arn is None and 'roleArn' in kwargs: + role_arn = kwargs['roleArn'] + if role_arn is None: + raise TypeError("Missing 'role_arn' argument") + if duration_seconds is None and 'durationSeconds' in kwargs: + duration_seconds = kwargs['durationSeconds'] + if external_id is None and 'externalId' in kwargs: + external_id = kwargs['externalId'] + if generate_credentials_in_worker is None and 'generateCredentialsInWorker' in kwargs: + generate_credentials_in_worker = kwargs['generateCredentialsInWorker'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + _setter("role_arn", role_arn) if duration_seconds is not None: - pulumi.set(__self__, "duration_seconds", duration_seconds) + _setter("duration_seconds", duration_seconds) if external_id is not None: - pulumi.set(__self__, "external_id", external_id) + _setter("external_id", external_id) if generate_credentials_in_worker is not None: - pulumi.set(__self__, "generate_credentials_in_worker", generate_credentials_in_worker) + _setter("generate_credentials_in_worker", generate_credentials_in_worker) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="roleArn") @@ -132,18 +167,51 @@ def __init__(__self__, *, :param pulumi.Input[str] role_arn: ARN of the AWS IAM role to attach :param pulumi.Input[str] stack_id: ID of the stack which assumes the AWS IAM role """ + _StackAwsRoleState._configure( + lambda key, value: pulumi.set(__self__, key, value), + duration_seconds=duration_seconds, + external_id=external_id, + generate_credentials_in_worker=generate_credentials_in_worker, + module_id=module_id, + role_arn=role_arn, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + duration_seconds: Optional[pulumi.Input[int]] = None, + external_id: Optional[pulumi.Input[str]] = None, + generate_credentials_in_worker: Optional[pulumi.Input[bool]] = None, + module_id: Optional[pulumi.Input[str]] = None, + role_arn: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if duration_seconds is None and 'durationSeconds' in kwargs: + duration_seconds = kwargs['durationSeconds'] + if external_id is None and 'externalId' in kwargs: + external_id = kwargs['externalId'] + if generate_credentials_in_worker is None and 'generateCredentialsInWorker' in kwargs: + generate_credentials_in_worker = kwargs['generateCredentialsInWorker'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if role_arn is None and 'roleArn' in kwargs: + role_arn = kwargs['roleArn'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if duration_seconds is not None: - pulumi.set(__self__, "duration_seconds", duration_seconds) + _setter("duration_seconds", duration_seconds) if external_id is not None: - pulumi.set(__self__, "external_id", external_id) + _setter("external_id", external_id) if generate_credentials_in_worker is not None: - pulumi.set(__self__, "generate_credentials_in_worker", generate_credentials_in_worker) + _setter("generate_credentials_in_worker", generate_credentials_in_worker) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if role_arn is not None: - pulumi.set(__self__, "role_arn", role_arn) + _setter("role_arn", role_arn) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="durationSeconds") @@ -277,6 +345,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + StackAwsRoleArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/stack_dependency.py b/sdk/python/pulumi_spacelift/stack_dependency.py new file mode 100644 index 0000000..8d07403 --- /dev/null +++ b/sdk/python/pulumi_spacelift/stack_dependency.py @@ -0,0 +1,270 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['StackDependencyArgs', 'StackDependency'] + +@pulumi.input_type +class StackDependencyArgs: + def __init__(__self__, *, + depends_on_stack_id: pulumi.Input[str], + stack_id: pulumi.Input[str]): + """ + The set of arguments for constructing a StackDependency resource. + :param pulumi.Input[str] depends_on_stack_id: immutable ID (slug) of stack to depend on. + :param pulumi.Input[str] stack_id: immutable ID (slug) of stack which has a dependency. + """ + StackDependencyArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + depends_on_stack_id=depends_on_stack_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + depends_on_stack_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if depends_on_stack_id is None and 'dependsOnStackId' in kwargs: + depends_on_stack_id = kwargs['dependsOnStackId'] + if depends_on_stack_id is None: + raise TypeError("Missing 'depends_on_stack_id' argument") + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if stack_id is None: + raise TypeError("Missing 'stack_id' argument") + + _setter("depends_on_stack_id", depends_on_stack_id) + _setter("stack_id", stack_id) + + @property + @pulumi.getter(name="dependsOnStackId") + def depends_on_stack_id(self) -> pulumi.Input[str]: + """ + immutable ID (slug) of stack to depend on. + """ + return pulumi.get(self, "depends_on_stack_id") + + @depends_on_stack_id.setter + def depends_on_stack_id(self, value: pulumi.Input[str]): + pulumi.set(self, "depends_on_stack_id", value) + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> pulumi.Input[str]: + """ + immutable ID (slug) of stack which has a dependency. + """ + return pulumi.get(self, "stack_id") + + @stack_id.setter + def stack_id(self, value: pulumi.Input[str]): + pulumi.set(self, "stack_id", value) + + +@pulumi.input_type +class _StackDependencyState: + def __init__(__self__, *, + depends_on_stack_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering StackDependency resources. + :param pulumi.Input[str] depends_on_stack_id: immutable ID (slug) of stack to depend on. + :param pulumi.Input[str] stack_id: immutable ID (slug) of stack which has a dependency. + """ + _StackDependencyState._configure( + lambda key, value: pulumi.set(__self__, key, value), + depends_on_stack_id=depends_on_stack_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + depends_on_stack_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if depends_on_stack_id is None and 'dependsOnStackId' in kwargs: + depends_on_stack_id = kwargs['dependsOnStackId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + if depends_on_stack_id is not None: + _setter("depends_on_stack_id", depends_on_stack_id) + if stack_id is not None: + _setter("stack_id", stack_id) + + @property + @pulumi.getter(name="dependsOnStackId") + def depends_on_stack_id(self) -> Optional[pulumi.Input[str]]: + """ + immutable ID (slug) of stack to depend on. + """ + return pulumi.get(self, "depends_on_stack_id") + + @depends_on_stack_id.setter + def depends_on_stack_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "depends_on_stack_id", value) + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> Optional[pulumi.Input[str]]: + """ + immutable ID (slug) of stack which has a dependency. + """ + return pulumi.get(self, "stack_id") + + @stack_id.setter + def stack_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "stack_id", value) + + +class StackDependency(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + depends_on_stack_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `StackDependency` represents a Spacelift **stack dependency** - a dependency between two stacks. When one stack depends on another, the tracked runs of the stack will not start until the dependent stack is successfully finished. Additionally, changes to the dependency will trigger the dependent. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + infra = spacelift.Stack("infra", + branch="master", + repository="core-infra") + app = spacelift.Stack("app", + branch="master", + repository="app") + test = spacelift.StackDependency("test", + stack_id=app.id, + depends_on_stack_id=infra.id) + ``` + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] depends_on_stack_id: immutable ID (slug) of stack to depend on. + :param pulumi.Input[str] stack_id: immutable ID (slug) of stack which has a dependency. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: StackDependencyArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `StackDependency` represents a Spacelift **stack dependency** - a dependency between two stacks. When one stack depends on another, the tracked runs of the stack will not start until the dependent stack is successfully finished. Additionally, changes to the dependency will trigger the dependent. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + infra = spacelift.Stack("infra", + branch="master", + repository="core-infra") + app = spacelift.Stack("app", + branch="master", + repository="app") + test = spacelift.StackDependency("test", + stack_id=app.id, + depends_on_stack_id=infra.id) + ``` + + :param str resource_name: The name of the resource. + :param StackDependencyArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(StackDependencyArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + StackDependencyArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + depends_on_stack_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = StackDependencyArgs.__new__(StackDependencyArgs) + + if depends_on_stack_id is None and not opts.urn: + raise TypeError("Missing required property 'depends_on_stack_id'") + __props__.__dict__["depends_on_stack_id"] = depends_on_stack_id + if stack_id is None and not opts.urn: + raise TypeError("Missing required property 'stack_id'") + __props__.__dict__["stack_id"] = stack_id + super(StackDependency, __self__).__init__( + 'spacelift:index/stackDependency:StackDependency', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + depends_on_stack_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None) -> 'StackDependency': + """ + Get an existing StackDependency resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] depends_on_stack_id: immutable ID (slug) of stack to depend on. + :param pulumi.Input[str] stack_id: immutable ID (slug) of stack which has a dependency. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _StackDependencyState.__new__(_StackDependencyState) + + __props__.__dict__["depends_on_stack_id"] = depends_on_stack_id + __props__.__dict__["stack_id"] = stack_id + return StackDependency(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="dependsOnStackId") + def depends_on_stack_id(self) -> pulumi.Output[str]: + """ + immutable ID (slug) of stack to depend on. + """ + return pulumi.get(self, "depends_on_stack_id") + + @property + @pulumi.getter(name="stackId") + def stack_id(self) -> pulumi.Output[str]: + """ + immutable ID (slug) of stack which has a dependency. + """ + return pulumi.get(self, "stack_id") + diff --git a/sdk/python/pulumi_spacelift/stack_dependency_reference.py b/sdk/python/pulumi_spacelift/stack_dependency_reference.py new file mode 100644 index 0000000..af714f8 --- /dev/null +++ b/sdk/python/pulumi_spacelift/stack_dependency_reference.py @@ -0,0 +1,336 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['StackDependencyReferenceArgs', 'StackDependencyReference'] + +@pulumi.input_type +class StackDependencyReferenceArgs: + def __init__(__self__, *, + input_name: pulumi.Input[str], + output_name: pulumi.Input[str], + stack_dependency_id: pulumi.Input[str]): + """ + The set of arguments for constructing a StackDependencyReference resource. + :param pulumi.Input[str] input_name: Name of the input of the stack dependency reference + :param pulumi.Input[str] output_name: Name of the output of stack to depend on + :param pulumi.Input[str] stack_dependency_id: Immutable ID of stack dependency + """ + StackDependencyReferenceArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + input_name=input_name, + output_name=output_name, + stack_dependency_id=stack_dependency_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + input_name: Optional[pulumi.Input[str]] = None, + output_name: Optional[pulumi.Input[str]] = None, + stack_dependency_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if input_name is None and 'inputName' in kwargs: + input_name = kwargs['inputName'] + if input_name is None: + raise TypeError("Missing 'input_name' argument") + if output_name is None and 'outputName' in kwargs: + output_name = kwargs['outputName'] + if output_name is None: + raise TypeError("Missing 'output_name' argument") + if stack_dependency_id is None and 'stackDependencyId' in kwargs: + stack_dependency_id = kwargs['stackDependencyId'] + if stack_dependency_id is None: + raise TypeError("Missing 'stack_dependency_id' argument") + + _setter("input_name", input_name) + _setter("output_name", output_name) + _setter("stack_dependency_id", stack_dependency_id) + + @property + @pulumi.getter(name="inputName") + def input_name(self) -> pulumi.Input[str]: + """ + Name of the input of the stack dependency reference + """ + return pulumi.get(self, "input_name") + + @input_name.setter + def input_name(self, value: pulumi.Input[str]): + pulumi.set(self, "input_name", value) + + @property + @pulumi.getter(name="outputName") + def output_name(self) -> pulumi.Input[str]: + """ + Name of the output of stack to depend on + """ + return pulumi.get(self, "output_name") + + @output_name.setter + def output_name(self, value: pulumi.Input[str]): + pulumi.set(self, "output_name", value) + + @property + @pulumi.getter(name="stackDependencyId") + def stack_dependency_id(self) -> pulumi.Input[str]: + """ + Immutable ID of stack dependency + """ + return pulumi.get(self, "stack_dependency_id") + + @stack_dependency_id.setter + def stack_dependency_id(self, value: pulumi.Input[str]): + pulumi.set(self, "stack_dependency_id", value) + + +@pulumi.input_type +class _StackDependencyReferenceState: + def __init__(__self__, *, + input_name: Optional[pulumi.Input[str]] = None, + output_name: Optional[pulumi.Input[str]] = None, + stack_dependency_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering StackDependencyReference resources. + :param pulumi.Input[str] input_name: Name of the input of the stack dependency reference + :param pulumi.Input[str] output_name: Name of the output of stack to depend on + :param pulumi.Input[str] stack_dependency_id: Immutable ID of stack dependency + """ + _StackDependencyReferenceState._configure( + lambda key, value: pulumi.set(__self__, key, value), + input_name=input_name, + output_name=output_name, + stack_dependency_id=stack_dependency_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + input_name: Optional[pulumi.Input[str]] = None, + output_name: Optional[pulumi.Input[str]] = None, + stack_dependency_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if input_name is None and 'inputName' in kwargs: + input_name = kwargs['inputName'] + if output_name is None and 'outputName' in kwargs: + output_name = kwargs['outputName'] + if stack_dependency_id is None and 'stackDependencyId' in kwargs: + stack_dependency_id = kwargs['stackDependencyId'] + + if input_name is not None: + _setter("input_name", input_name) + if output_name is not None: + _setter("output_name", output_name) + if stack_dependency_id is not None: + _setter("stack_dependency_id", stack_dependency_id) + + @property + @pulumi.getter(name="inputName") + def input_name(self) -> Optional[pulumi.Input[str]]: + """ + Name of the input of the stack dependency reference + """ + return pulumi.get(self, "input_name") + + @input_name.setter + def input_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "input_name", value) + + @property + @pulumi.getter(name="outputName") + def output_name(self) -> Optional[pulumi.Input[str]]: + """ + Name of the output of stack to depend on + """ + return pulumi.get(self, "output_name") + + @output_name.setter + def output_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "output_name", value) + + @property + @pulumi.getter(name="stackDependencyId") + def stack_dependency_id(self) -> Optional[pulumi.Input[str]]: + """ + Immutable ID of stack dependency + """ + return pulumi.get(self, "stack_dependency_id") + + @stack_dependency_id.setter + def stack_dependency_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "stack_dependency_id", value) + + +class StackDependencyReference(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + input_name: Optional[pulumi.Input[str]] = None, + output_name: Optional[pulumi.Input[str]] = None, + stack_dependency_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `StackDependencyReference` represents a Spacelift **stack dependency reference** - a reference matches a stack's output to another stack's input. It is similar to an environment variable (`EnvironmentVariable`), except that value is provided by another stack's output. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + infra = spacelift.Stack("infra", + branch="master", + repository="core-infra") + app = spacelift.Stack("app", + branch="master", + repository="app") + test_stack_dependency = spacelift.StackDependency("testStackDependency", + stack_id=app.id, + depends_on_stack_id=infra.id) + test_stack_dependency_reference = spacelift.StackDependencyReference("testStackDependencyReference", + stack_dependency_id=test_stack_dependency.id, + output_name="DB_CONNECTION_STRING", + input_name="APP_DB_URL") + ``` + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] input_name: Name of the input of the stack dependency reference + :param pulumi.Input[str] output_name: Name of the output of stack to depend on + :param pulumi.Input[str] stack_dependency_id: Immutable ID of stack dependency + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: StackDependencyReferenceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `StackDependencyReference` represents a Spacelift **stack dependency reference** - a reference matches a stack's output to another stack's input. It is similar to an environment variable (`EnvironmentVariable`), except that value is provided by another stack's output. + + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + infra = spacelift.Stack("infra", + branch="master", + repository="core-infra") + app = spacelift.Stack("app", + branch="master", + repository="app") + test_stack_dependency = spacelift.StackDependency("testStackDependency", + stack_id=app.id, + depends_on_stack_id=infra.id) + test_stack_dependency_reference = spacelift.StackDependencyReference("testStackDependencyReference", + stack_dependency_id=test_stack_dependency.id, + output_name="DB_CONNECTION_STRING", + input_name="APP_DB_URL") + ``` + + :param str resource_name: The name of the resource. + :param StackDependencyReferenceArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(StackDependencyReferenceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + StackDependencyReferenceArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + input_name: Optional[pulumi.Input[str]] = None, + output_name: Optional[pulumi.Input[str]] = None, + stack_dependency_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = StackDependencyReferenceArgs.__new__(StackDependencyReferenceArgs) + + if input_name is None and not opts.urn: + raise TypeError("Missing required property 'input_name'") + __props__.__dict__["input_name"] = input_name + if output_name is None and not opts.urn: + raise TypeError("Missing required property 'output_name'") + __props__.__dict__["output_name"] = output_name + if stack_dependency_id is None and not opts.urn: + raise TypeError("Missing required property 'stack_dependency_id'") + __props__.__dict__["stack_dependency_id"] = stack_dependency_id + super(StackDependencyReference, __self__).__init__( + 'spacelift:index/stackDependencyReference:StackDependencyReference', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + input_name: Optional[pulumi.Input[str]] = None, + output_name: Optional[pulumi.Input[str]] = None, + stack_dependency_id: Optional[pulumi.Input[str]] = None) -> 'StackDependencyReference': + """ + Get an existing StackDependencyReference resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] input_name: Name of the input of the stack dependency reference + :param pulumi.Input[str] output_name: Name of the output of stack to depend on + :param pulumi.Input[str] stack_dependency_id: Immutable ID of stack dependency + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _StackDependencyReferenceState.__new__(_StackDependencyReferenceState) + + __props__.__dict__["input_name"] = input_name + __props__.__dict__["output_name"] = output_name + __props__.__dict__["stack_dependency_id"] = stack_dependency_id + return StackDependencyReference(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="inputName") + def input_name(self) -> pulumi.Output[str]: + """ + Name of the input of the stack dependency reference + """ + return pulumi.get(self, "input_name") + + @property + @pulumi.getter(name="outputName") + def output_name(self) -> pulumi.Output[str]: + """ + Name of the output of stack to depend on + """ + return pulumi.get(self, "output_name") + + @property + @pulumi.getter(name="stackDependencyId") + def stack_dependency_id(self) -> pulumi.Output[str]: + """ + Immutable ID of stack dependency + """ + return pulumi.get(self, "stack_dependency_id") + diff --git a/sdk/python/pulumi_spacelift/stack_destructor.py b/sdk/python/pulumi_spacelift/stack_destructor.py index de8564d..07513c9 100644 --- a/sdk/python/pulumi_spacelift/stack_destructor.py +++ b/sdk/python/pulumi_spacelift/stack_destructor.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['StackDestructorArgs', 'StackDestructor'] @@ -21,9 +21,26 @@ def __init__(__self__, *, :param pulumi.Input[str] stack_id: ID of the stack to delete and destroy on destruction :param pulumi.Input[bool] deactivated: If set to true, destruction won't delete the stack """ - pulumi.set(__self__, "stack_id", stack_id) + StackDestructorArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + stack_id=stack_id, + deactivated=deactivated, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + stack_id: Optional[pulumi.Input[str]] = None, + deactivated: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if stack_id is None: + raise TypeError("Missing 'stack_id' argument") + + _setter("stack_id", stack_id) if deactivated is not None: - pulumi.set(__self__, "deactivated", deactivated) + _setter("deactivated", deactivated) @property @pulumi.getter(name="stackId") @@ -60,10 +77,25 @@ def __init__(__self__, *, :param pulumi.Input[bool] deactivated: If set to true, destruction won't delete the stack :param pulumi.Input[str] stack_id: ID of the stack to delete and destroy on destruction """ + _StackDestructorState._configure( + lambda key, value: pulumi.set(__self__, key, value), + deactivated=deactivated, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + deactivated: Optional[pulumi.Input[bool]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if deactivated is not None: - pulumi.set(__self__, "deactivated", deactivated) + _setter("deactivated", deactivated) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter @@ -153,6 +185,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + StackDestructorArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/stack_gcp_service_account.py b/sdk/python/pulumi_spacelift/stack_gcp_service_account.py index 5f068fd..655899e 100644 --- a/sdk/python/pulumi_spacelift/stack_gcp_service_account.py +++ b/sdk/python/pulumi_spacelift/stack_gcp_service_account.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['StackGcpServiceAccountArgs', 'StackGcpServiceAccount'] @@ -23,11 +23,34 @@ def __init__(__self__, *, :param pulumi.Input[str] module_id: ID of the module which uses GCP service account credentials :param pulumi.Input[str] stack_id: ID of the stack which uses GCP service account credentials """ - pulumi.set(__self__, "token_scopes", token_scopes) + StackGcpServiceAccountArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + token_scopes=token_scopes, + module_id=module_id, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + token_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + module_id: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if token_scopes is None and 'tokenScopes' in kwargs: + token_scopes = kwargs['tokenScopes'] + if token_scopes is None: + raise TypeError("Missing 'token_scopes' argument") + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + _setter("token_scopes", token_scopes) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter(name="tokenScopes") @@ -80,14 +103,39 @@ def __init__(__self__, *, :param pulumi.Input[str] stack_id: ID of the stack which uses GCP service account credentials :param pulumi.Input[Sequence[pulumi.Input[str]]] token_scopes: List of scopes that will be requested when generating temporary GCP service account credentials """ + _StackGcpServiceAccountState._configure( + lambda key, value: pulumi.set(__self__, key, value), + module_id=module_id, + service_account_email=service_account_email, + stack_id=stack_id, + token_scopes=token_scopes, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + module_id: Optional[pulumi.Input[str]] = None, + service_account_email: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + token_scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if service_account_email is None and 'serviceAccountEmail' in kwargs: + service_account_email = kwargs['serviceAccountEmail'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if token_scopes is None and 'tokenScopes' in kwargs: + token_scopes = kwargs['tokenScopes'] + if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if service_account_email is not None: - pulumi.set(__self__, "service_account_email", service_account_email) + _setter("service_account_email", service_account_email) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) if token_scopes is not None: - pulumi.set(__self__, "token_scopes", token_scopes) + _setter("token_scopes", token_scopes) @property @pulumi.getter(name="moduleId") @@ -152,7 +200,7 @@ def __init__(__self__, ```python import pulumi - import pulumi_gcp as gcp + import pulumi_google as google import pulumi_spacelift as spacelift k8s_core_stack = spacelift.Stack("k8s-coreStack", @@ -165,13 +213,14 @@ def __init__(__self__, "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/devstorage.full_control", ]) - k8s_core_project = gcp.organizations.Project("k8s-coreProject", - project_id="unicorn-k8s-core", - org_id=var["gcp_organization_id"]) - k8s_core_iam_member = gcp.projects.IAMMember("k8s-coreIAMMember", - project=k8s_core_project.id, - role="roles/owner", - member=k8s_core_stack_gcp_service_account.service_account_email.apply(lambda service_account_email: f"serviceAccount:{service_account_email}")) + k8s_coregoogle_project = google.index.Google_project("k8s-coregoogle_project", + name=Kubernetes code, + project_id=unicorn-k8s-core, + org_id=var.gcp_organization_id) + k8s_coregoogle_project_iam_member = google.index.Google_project_iam_member("k8s-coregoogle_project_iam_member", + project=k8s_coregoogle_project.id, + role=roles/owner, + member=fserviceAccount:{k8s_core_stack_gcp_service_account.service_account_email}) ``` :param str resource_name: The name of the resource. @@ -191,7 +240,7 @@ def __init__(__self__, ```python import pulumi - import pulumi_gcp as gcp + import pulumi_google as google import pulumi_spacelift as spacelift k8s_core_stack = spacelift.Stack("k8s-coreStack", @@ -204,13 +253,14 @@ def __init__(__self__, "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/devstorage.full_control", ]) - k8s_core_project = gcp.organizations.Project("k8s-coreProject", - project_id="unicorn-k8s-core", - org_id=var["gcp_organization_id"]) - k8s_core_iam_member = gcp.projects.IAMMember("k8s-coreIAMMember", - project=k8s_core_project.id, - role="roles/owner", - member=k8s_core_stack_gcp_service_account.service_account_email.apply(lambda service_account_email: f"serviceAccount:{service_account_email}")) + k8s_coregoogle_project = google.index.Google_project("k8s-coregoogle_project", + name=Kubernetes code, + project_id=unicorn-k8s-core, + org_id=var.gcp_organization_id) + k8s_coregoogle_project_iam_member = google.index.Google_project_iam_member("k8s-coregoogle_project_iam_member", + project=k8s_coregoogle_project.id, + role=roles/owner, + member=fserviceAccount:{k8s_core_stack_gcp_service_account.service_account_email}) ``` :param str resource_name: The name of the resource. @@ -223,6 +273,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + StackGcpServiceAccountArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, diff --git a/sdk/python/pulumi_spacelift/terraform_provider.py b/sdk/python/pulumi_spacelift/terraform_provider.py new file mode 100644 index 0000000..7fc26b3 --- /dev/null +++ b/sdk/python/pulumi_spacelift/terraform_provider.py @@ -0,0 +1,396 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['TerraformProviderArgs', 'TerraformProvider'] + +@pulumi.input_type +class TerraformProviderArgs: + def __init__(__self__, *, + space_id: pulumi.Input[str], + type: pulumi.Input[str], + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + public: Optional[pulumi.Input[bool]] = None): + """ + The set of arguments for constructing a TerraformProvider resource. + :param pulumi.Input[str] space_id: ID (slug) of the space the provider is in + :param pulumi.Input[str] type: Type of the provider - should be unique in one account + :param pulumi.Input[str] description: Free-form description for human users, supports Markdown + :param pulumi.Input[bool] public: Whether the provider is public or not, defaults to false (private) + """ + TerraformProviderArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + space_id=space_id, + type=type, + description=description, + labels=labels, + public=public, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + space_id: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + public: Optional[pulumi.Input[bool]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if space_id is None: + raise TypeError("Missing 'space_id' argument") + if type is None: + raise TypeError("Missing 'type' argument") + + _setter("space_id", space_id) + _setter("type", type) + if description is not None: + _setter("description", description) + if labels is not None: + _setter("labels", labels) + if public is not None: + _setter("public", public) + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> pulumi.Input[str]: + """ + ID (slug) of the space the provider is in + """ + return pulumi.get(self, "space_id") + + @space_id.setter + def space_id(self, value: pulumi.Input[str]): + pulumi.set(self, "space_id", value) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[str]: + """ + Type of the provider - should be unique in one account + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[str]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + """ + Free-form description for human users, supports Markdown + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def public(self) -> Optional[pulumi.Input[bool]]: + """ + Whether the provider is public or not, defaults to false (private) + """ + return pulumi.get(self, "public") + + @public.setter + def public(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "public", value) + + +@pulumi.input_type +class _TerraformProviderState: + def __init__(__self__, *, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + public: Optional[pulumi.Input[bool]] = None, + space_id: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering TerraformProvider resources. + :param pulumi.Input[str] description: Free-form description for human users, supports Markdown + :param pulumi.Input[bool] public: Whether the provider is public or not, defaults to false (private) + :param pulumi.Input[str] space_id: ID (slug) of the space the provider is in + :param pulumi.Input[str] type: Type of the provider - should be unique in one account + """ + _TerraformProviderState._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + labels=labels, + public=public, + space_id=space_id, + type=type, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + public: Optional[pulumi.Input[bool]] = None, + space_id: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + + if description is not None: + _setter("description", description) + if labels is not None: + _setter("labels", labels) + if public is not None: + _setter("public", public) + if space_id is not None: + _setter("space_id", space_id) + if type is not None: + _setter("type", type) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + """ + Free-form description for human users, supports Markdown + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def public(self) -> Optional[pulumi.Input[bool]]: + """ + Whether the provider is public or not, defaults to false (private) + """ + return pulumi.get(self, "public") + + @public.setter + def public(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "public", value) + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> Optional[pulumi.Input[str]]: + """ + ID (slug) of the space the provider is in + """ + return pulumi.get(self, "space_id") + + @space_id.setter + def space_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "space_id", value) + + @property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[str]]: + """ + Type of the provider - should be unique in one account + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "type", value) + + +class TerraformProvider(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + public: Optional[pulumi.Input[bool]] = None, + space_id: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + datadog = spacelift.TerraformProvider("datadog", + description="Our fork of the Datadog provider", + labels=["fork"], + public=False, + space_id="root", + type="datadog") + ``` + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] description: Free-form description for human users, supports Markdown + :param pulumi.Input[bool] public: Whether the provider is public or not, defaults to false (private) + :param pulumi.Input[str] space_id: ID (slug) of the space the provider is in + :param pulumi.Input[str] type: Type of the provider - should be unique in one account + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: TerraformProviderArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + ## Example Usage + + ```python + import pulumi + import pulumi_spacelift as spacelift + + datadog = spacelift.TerraformProvider("datadog", + description="Our fork of the Datadog provider", + labels=["fork"], + public=False, + space_id="root", + type="datadog") + ``` + + :param str resource_name: The name of the resource. + :param TerraformProviderArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(TerraformProviderArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + TerraformProviderArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + public: Optional[pulumi.Input[bool]] = None, + space_id: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = TerraformProviderArgs.__new__(TerraformProviderArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["public"] = public + if space_id is None and not opts.urn: + raise TypeError("Missing required property 'space_id'") + __props__.__dict__["space_id"] = space_id + if type is None and not opts.urn: + raise TypeError("Missing required property 'type'") + __props__.__dict__["type"] = type + super(TerraformProvider, __self__).__init__( + 'spacelift:index/terraformProvider:TerraformProvider', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + public: Optional[pulumi.Input[bool]] = None, + space_id: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None) -> 'TerraformProvider': + """ + Get an existing TerraformProvider resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] description: Free-form description for human users, supports Markdown + :param pulumi.Input[bool] public: Whether the provider is public or not, defaults to false (private) + :param pulumi.Input[str] space_id: ID (slug) of the space the provider is in + :param pulumi.Input[str] type: Type of the provider - should be unique in one account + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TerraformProviderState.__new__(_TerraformProviderState) + + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["public"] = public + __props__.__dict__["space_id"] = space_id + __props__.__dict__["type"] = type + return TerraformProvider(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + """ + Free-form description for human users, supports Markdown + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Sequence[str]]]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def public(self) -> pulumi.Output[Optional[bool]]: + """ + Whether the provider is public or not, defaults to false (private) + """ + return pulumi.get(self, "public") + + @property + @pulumi.getter(name="spaceId") + def space_id(self) -> pulumi.Output[str]: + """ + ID (slug) of the space the provider is in + """ + return pulumi.get(self, "space_id") + + @property + @pulumi.getter + def type(self) -> pulumi.Output[str]: + """ + Type of the provider - should be unique in one account + """ + return pulumi.get(self, "type") + diff --git a/sdk/python/pulumi_spacelift/user.py b/sdk/python/pulumi_spacelift/user.py new file mode 100644 index 0000000..7f08896 --- /dev/null +++ b/sdk/python/pulumi_spacelift/user.py @@ -0,0 +1,275 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['UserArgs', 'User'] + +@pulumi.input_type +class UserArgs: + def __init__(__self__, *, + invitation_email: pulumi.Input[str], + policies: pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]], + username: pulumi.Input[str]): + """ + The set of arguments for constructing a User resource. + :param pulumi.Input[str] invitation_email: Email of the user. Used for sending an invitation. + :param pulumi.Input[str] username: Username of the user + """ + UserArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + invitation_email=invitation_email, + policies=policies, + username=username, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + invitation_email: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]] = None, + username: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if invitation_email is None and 'invitationEmail' in kwargs: + invitation_email = kwargs['invitationEmail'] + if invitation_email is None: + raise TypeError("Missing 'invitation_email' argument") + if policies is None: + raise TypeError("Missing 'policies' argument") + if username is None: + raise TypeError("Missing 'username' argument") + + _setter("invitation_email", invitation_email) + _setter("policies", policies) + _setter("username", username) + + @property + @pulumi.getter(name="invitationEmail") + def invitation_email(self) -> pulumi.Input[str]: + """ + Email of the user. Used for sending an invitation. + """ + return pulumi.get(self, "invitation_email") + + @invitation_email.setter + def invitation_email(self, value: pulumi.Input[str]): + pulumi.set(self, "invitation_email", value) + + @property + @pulumi.getter + def policies(self) -> pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]: + return pulumi.get(self, "policies") + + @policies.setter + def policies(self, value: pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]): + pulumi.set(self, "policies", value) + + @property + @pulumi.getter + def username(self) -> pulumi.Input[str]: + """ + Username of the user + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: pulumi.Input[str]): + pulumi.set(self, "username", value) + + +@pulumi.input_type +class _UserState: + def __init__(__self__, *, + invitation_email: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]] = None, + username: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering User resources. + :param pulumi.Input[str] invitation_email: Email of the user. Used for sending an invitation. + :param pulumi.Input[str] username: Username of the user + """ + _UserState._configure( + lambda key, value: pulumi.set(__self__, key, value), + invitation_email=invitation_email, + policies=policies, + username=username, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + invitation_email: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]] = None, + username: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if invitation_email is None and 'invitationEmail' in kwargs: + invitation_email = kwargs['invitationEmail'] + + if invitation_email is not None: + _setter("invitation_email", invitation_email) + if policies is not None: + _setter("policies", policies) + if username is not None: + _setter("username", username) + + @property + @pulumi.getter(name="invitationEmail") + def invitation_email(self) -> Optional[pulumi.Input[str]]: + """ + Email of the user. Used for sending an invitation. + """ + return pulumi.get(self, "invitation_email") + + @invitation_email.setter + def invitation_email(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "invitation_email", value) + + @property + @pulumi.getter + def policies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]]: + return pulumi.get(self, "policies") + + @policies.setter + def policies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['UserPolicyArgs']]]]): + pulumi.set(self, "policies", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[str]]: + """ + Username of the user + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "username", value) + + +class User(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + invitation_email: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['UserPolicyArgs']]]]] = None, + username: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `User` represents a mapping between a Spacelift user (managed using an Identity Provider) and a Policy. A Policy defines what access rights the user has to a given Space. + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] invitation_email: Email of the user. Used for sending an invitation. + :param pulumi.Input[str] username: Username of the user + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: UserArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `User` represents a mapping between a Spacelift user (managed using an Identity Provider) and a Policy. A Policy defines what access rights the user has to a given Space. + + :param str resource_name: The name of the resource. + :param UserArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(UserArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + UserArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + invitation_email: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['UserPolicyArgs']]]]] = None, + username: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = UserArgs.__new__(UserArgs) + + if invitation_email is None and not opts.urn: + raise TypeError("Missing required property 'invitation_email'") + __props__.__dict__["invitation_email"] = invitation_email + if policies is None and not opts.urn: + raise TypeError("Missing required property 'policies'") + __props__.__dict__["policies"] = policies + if username is None and not opts.urn: + raise TypeError("Missing required property 'username'") + __props__.__dict__["username"] = username + super(User, __self__).__init__( + 'spacelift:index/user:User', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + invitation_email: Optional[pulumi.Input[str]] = None, + policies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['UserPolicyArgs']]]]] = None, + username: Optional[pulumi.Input[str]] = None) -> 'User': + """ + Get an existing User resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] invitation_email: Email of the user. Used for sending an invitation. + :param pulumi.Input[str] username: Username of the user + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _UserState.__new__(_UserState) + + __props__.__dict__["invitation_email"] = invitation_email + __props__.__dict__["policies"] = policies + __props__.__dict__["username"] = username + return User(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="invitationEmail") + def invitation_email(self) -> pulumi.Output[str]: + """ + Email of the user. Used for sending an invitation. + """ + return pulumi.get(self, "invitation_email") + + @property + @pulumi.getter + def policies(self) -> pulumi.Output[Sequence['outputs.UserPolicy']]: + return pulumi.get(self, "policies") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[str]: + """ + Username of the user + """ + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_spacelift/vcs_agent_pool.py b/sdk/python/pulumi_spacelift/vcs_agent_pool.py index 429c5a3..d25505e 100644 --- a/sdk/python/pulumi_spacelift/vcs_agent_pool.py +++ b/sdk/python/pulumi_spacelift/vcs_agent_pool.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['VcsAgentPoolArgs', 'VcsAgentPool'] @@ -21,10 +21,23 @@ def __init__(__self__, *, :param pulumi.Input[str] description: Free-form VCS agent pool description for users :param pulumi.Input[str] name: Name of the VCS agent pool, must be unique within an account """ + VcsAgentPoolArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + description=description, + name=name, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + description: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) @property @pulumi.getter @@ -63,12 +76,27 @@ def __init__(__self__, *, :param pulumi.Input[str] description: Free-form VCS agent pool description for users :param pulumi.Input[str] name: Name of the VCS agent pool, must be unique within an account """ + _VcsAgentPoolState._configure( + lambda key, value: pulumi.set(__self__, key, value), + config=config, + description=description, + name=name, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + config: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if config is not None: - pulumi.set(__self__, "config", config) + _setter("config", config) if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) @property @pulumi.getter @@ -172,6 +200,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + VcsAgentPoolArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -191,6 +223,8 @@ def _internal_init(__self__, __props__.__dict__["description"] = description __props__.__dict__["name"] = name __props__.__dict__["config"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["config"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) super(VcsAgentPool, __self__).__init__( 'spacelift:index/vcsAgentPool:VcsAgentPool', resource_name, diff --git a/sdk/python/pulumi_spacelift/version.py b/sdk/python/pulumi_spacelift/version.py new file mode 100644 index 0000000..359374d --- /dev/null +++ b/sdk/python/pulumi_spacelift/version.py @@ -0,0 +1,339 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['VersionArgs', 'Version'] + +@pulumi.input_type +class VersionArgs: + def __init__(__self__, *, + module_id: pulumi.Input[str], + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + version_number: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a Version resource. + :param pulumi.Input[str] module_id: ID of the module on which the version creation is to be triggered. + :param pulumi.Input[str] commit_sha: The commit SHA for which to trigger a version. + :param pulumi.Input[Mapping[str, Any]] keepers: Arbitrary map of values that, when changed, will trigger recreation of the resource. + :param pulumi.Input[str] version_number: A semantic version number to set for the triggered version, example: 0.11.2 + """ + VersionArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + module_id=module_id, + commit_sha=commit_sha, + keepers=keepers, + version_number=version_number, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + module_id: Optional[pulumi.Input[str]] = None, + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + version_number: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if module_id is None: + raise TypeError("Missing 'module_id' argument") + if commit_sha is None and 'commitSha' in kwargs: + commit_sha = kwargs['commitSha'] + if version_number is None and 'versionNumber' in kwargs: + version_number = kwargs['versionNumber'] + + _setter("module_id", module_id) + if commit_sha is not None: + _setter("commit_sha", commit_sha) + if keepers is not None: + _setter("keepers", keepers) + if version_number is not None: + _setter("version_number", version_number) + + @property + @pulumi.getter(name="moduleId") + def module_id(self) -> pulumi.Input[str]: + """ + ID of the module on which the version creation is to be triggered. + """ + return pulumi.get(self, "module_id") + + @module_id.setter + def module_id(self, value: pulumi.Input[str]): + pulumi.set(self, "module_id", value) + + @property + @pulumi.getter(name="commitSha") + def commit_sha(self) -> Optional[pulumi.Input[str]]: + """ + The commit SHA for which to trigger a version. + """ + return pulumi.get(self, "commit_sha") + + @commit_sha.setter + def commit_sha(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "commit_sha", value) + + @property + @pulumi.getter + def keepers(self) -> Optional[pulumi.Input[Mapping[str, Any]]]: + """ + Arbitrary map of values that, when changed, will trigger recreation of the resource. + """ + return pulumi.get(self, "keepers") + + @keepers.setter + def keepers(self, value: Optional[pulumi.Input[Mapping[str, Any]]]): + pulumi.set(self, "keepers", value) + + @property + @pulumi.getter(name="versionNumber") + def version_number(self) -> Optional[pulumi.Input[str]]: + """ + A semantic version number to set for the triggered version, example: 0.11.2 + """ + return pulumi.get(self, "version_number") + + @version_number.setter + def version_number(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "version_number", value) + + +@pulumi.input_type +class _VersionState: + def __init__(__self__, *, + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + module_id: Optional[pulumi.Input[str]] = None, + version_number: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering Version resources. + :param pulumi.Input[str] commit_sha: The commit SHA for which to trigger a version. + :param pulumi.Input[Mapping[str, Any]] keepers: Arbitrary map of values that, when changed, will trigger recreation of the resource. + :param pulumi.Input[str] module_id: ID of the module on which the version creation is to be triggered. + :param pulumi.Input[str] version_number: A semantic version number to set for the triggered version, example: 0.11.2 + """ + _VersionState._configure( + lambda key, value: pulumi.set(__self__, key, value), + commit_sha=commit_sha, + keepers=keepers, + module_id=module_id, + version_number=version_number, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + module_id: Optional[pulumi.Input[str]] = None, + version_number: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if commit_sha is None and 'commitSha' in kwargs: + commit_sha = kwargs['commitSha'] + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if version_number is None and 'versionNumber' in kwargs: + version_number = kwargs['versionNumber'] + + if commit_sha is not None: + _setter("commit_sha", commit_sha) + if keepers is not None: + _setter("keepers", keepers) + if module_id is not None: + _setter("module_id", module_id) + if version_number is not None: + _setter("version_number", version_number) + + @property + @pulumi.getter(name="commitSha") + def commit_sha(self) -> Optional[pulumi.Input[str]]: + """ + The commit SHA for which to trigger a version. + """ + return pulumi.get(self, "commit_sha") + + @commit_sha.setter + def commit_sha(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "commit_sha", value) + + @property + @pulumi.getter + def keepers(self) -> Optional[pulumi.Input[Mapping[str, Any]]]: + """ + Arbitrary map of values that, when changed, will trigger recreation of the resource. + """ + return pulumi.get(self, "keepers") + + @keepers.setter + def keepers(self, value: Optional[pulumi.Input[Mapping[str, Any]]]): + pulumi.set(self, "keepers", value) + + @property + @pulumi.getter(name="moduleId") + def module_id(self) -> Optional[pulumi.Input[str]]: + """ + ID of the module on which the version creation is to be triggered. + """ + return pulumi.get(self, "module_id") + + @module_id.setter + def module_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "module_id", value) + + @property + @pulumi.getter(name="versionNumber") + def version_number(self) -> Optional[pulumi.Input[str]]: + """ + A semantic version number to set for the triggered version, example: 0.11.2 + """ + return pulumi.get(self, "version_number") + + @version_number.setter + def version_number(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "version_number", value) + + +class Version(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + module_id: Optional[pulumi.Input[str]] = None, + version_number: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + `Version` allows to programmatically trigger a version creation in response to arbitrary changes in the keepers section. + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] commit_sha: The commit SHA for which to trigger a version. + :param pulumi.Input[Mapping[str, Any]] keepers: Arbitrary map of values that, when changed, will trigger recreation of the resource. + :param pulumi.Input[str] module_id: ID of the module on which the version creation is to be triggered. + :param pulumi.Input[str] version_number: A semantic version number to set for the triggered version, example: 0.11.2 + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: VersionArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + `Version` allows to programmatically trigger a version creation in response to arbitrary changes in the keepers section. + + :param str resource_name: The name of the resource. + :param VersionArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(VersionArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + VersionArgs._configure(_setter, **kwargs) + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + module_id: Optional[pulumi.Input[str]] = None, + version_number: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = VersionArgs.__new__(VersionArgs) + + __props__.__dict__["commit_sha"] = commit_sha + __props__.__dict__["keepers"] = keepers + if module_id is None and not opts.urn: + raise TypeError("Missing required property 'module_id'") + __props__.__dict__["module_id"] = module_id + __props__.__dict__["version_number"] = version_number + super(Version, __self__).__init__( + 'spacelift:index/version:Version', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + commit_sha: Optional[pulumi.Input[str]] = None, + keepers: Optional[pulumi.Input[Mapping[str, Any]]] = None, + module_id: Optional[pulumi.Input[str]] = None, + version_number: Optional[pulumi.Input[str]] = None) -> 'Version': + """ + Get an existing Version resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] commit_sha: The commit SHA for which to trigger a version. + :param pulumi.Input[Mapping[str, Any]] keepers: Arbitrary map of values that, when changed, will trigger recreation of the resource. + :param pulumi.Input[str] module_id: ID of the module on which the version creation is to be triggered. + :param pulumi.Input[str] version_number: A semantic version number to set for the triggered version, example: 0.11.2 + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _VersionState.__new__(_VersionState) + + __props__.__dict__["commit_sha"] = commit_sha + __props__.__dict__["keepers"] = keepers + __props__.__dict__["module_id"] = module_id + __props__.__dict__["version_number"] = version_number + return Version(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="commitSha") + def commit_sha(self) -> pulumi.Output[Optional[str]]: + """ + The commit SHA for which to trigger a version. + """ + return pulumi.get(self, "commit_sha") + + @property + @pulumi.getter + def keepers(self) -> pulumi.Output[Optional[Mapping[str, Any]]]: + """ + Arbitrary map of values that, when changed, will trigger recreation of the resource. + """ + return pulumi.get(self, "keepers") + + @property + @pulumi.getter(name="moduleId") + def module_id(self) -> pulumi.Output[str]: + """ + ID of the module on which the version creation is to be triggered. + """ + return pulumi.get(self, "module_id") + + @property + @pulumi.getter(name="versionNumber") + def version_number(self) -> pulumi.Output[Optional[str]]: + """ + A semantic version number to set for the triggered version, example: 0.11.2 + """ + return pulumi.get(self, "version_number") + diff --git a/sdk/python/pulumi_spacelift/webhook.py b/sdk/python/pulumi_spacelift/webhook.py index fd27715..436df9e 100644 --- a/sdk/python/pulumi_spacelift/webhook.py +++ b/sdk/python/pulumi_spacelift/webhook.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['WebhookArgs', 'Webhook'] @@ -27,15 +27,40 @@ def __init__(__self__, *, :param pulumi.Input[str] secret: secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. :param pulumi.Input[str] stack_id: ID of the stack which triggers the webhooks """ - pulumi.set(__self__, "endpoint", endpoint) + WebhookArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + endpoint=endpoint, + enabled=enabled, + module_id=module_id, + secret=secret, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + endpoint: Optional[pulumi.Input[str]] = None, + enabled: Optional[pulumi.Input[bool]] = None, + module_id: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if endpoint is None: + raise TypeError("Missing 'endpoint' argument") + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + + _setter("endpoint", endpoint) if enabled is not None: - pulumi.set(__self__, "enabled", enabled) + _setter("enabled", enabled) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if secret is not None: - pulumi.set(__self__, "secret", secret) + _setter("secret", secret) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter @@ -114,16 +139,39 @@ def __init__(__self__, *, :param pulumi.Input[str] secret: secret used to sign each POST request so you're able to verify that the request comes from us. Defaults to an empty value. :param pulumi.Input[str] stack_id: ID of the stack which triggers the webhooks """ + _WebhookState._configure( + lambda key, value: pulumi.set(__self__, key, value), + enabled=enabled, + endpoint=endpoint, + module_id=module_id, + secret=secret, + stack_id=stack_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + enabled: Optional[pulumi.Input[bool]] = None, + endpoint: Optional[pulumi.Input[str]] = None, + module_id: Optional[pulumi.Input[str]] = None, + secret: Optional[pulumi.Input[str]] = None, + stack_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if module_id is None and 'moduleId' in kwargs: + module_id = kwargs['moduleId'] + if stack_id is None and 'stackId' in kwargs: + stack_id = kwargs['stackId'] + if enabled is not None: - pulumi.set(__self__, "enabled", enabled) + _setter("enabled", enabled) if endpoint is not None: - pulumi.set(__self__, "endpoint", endpoint) + _setter("endpoint", endpoint) if module_id is not None: - pulumi.set(__self__, "module_id", module_id) + _setter("module_id", module_id) if secret is not None: - pulumi.set(__self__, "secret", secret) + _setter("secret", secret) if stack_id is not None: - pulumi.set(__self__, "stack_id", stack_id) + _setter("stack_id", stack_id) @property @pulumi.getter @@ -261,6 +309,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + WebhookArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -285,8 +337,10 @@ def _internal_init(__self__, raise TypeError("Missing required property 'endpoint'") __props__.__dict__["endpoint"] = endpoint __props__.__dict__["module_id"] = module_id - __props__.__dict__["secret"] = secret + __props__.__dict__["secret"] = None if secret is None else pulumi.Output.secret(secret) __props__.__dict__["stack_id"] = stack_id + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["secret"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) super(Webhook, __self__).__init__( 'spacelift:index/webhook:Webhook', resource_name, diff --git a/sdk/python/pulumi_spacelift/worker_pool.py b/sdk/python/pulumi_spacelift/worker_pool.py index 9f913cf..309d1b5 100644 --- a/sdk/python/pulumi_spacelift/worker_pool.py +++ b/sdk/python/pulumi_spacelift/worker_pool.py @@ -6,7 +6,7 @@ import warnings import pulumi import pulumi.runtime -from typing import Any, Mapping, Optional, Sequence, Union, overload +from typing import Any, Callable, Mapping, Optional, Sequence, Union, overload from . import _utilities __all__ = ['WorkerPoolArgs', 'WorkerPool'] @@ -26,16 +26,37 @@ def __init__(__self__, *, :param pulumi.Input[str] name: name of the worker pool :param pulumi.Input[str] space_id: ID (slug) of the space the worker pool is in """ + WorkerPoolArgs._configure( + lambda key, value: pulumi.set(__self__, key, value), + csr=csr, + description=description, + labels=labels, + name=name, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + csr: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if csr is not None: - pulumi.set(__self__, "csr", csr) + _setter("csr", csr) if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) @property @pulumi.getter @@ -114,20 +135,47 @@ def __init__(__self__, *, :param pulumi.Input[str] private_key: private key in base64 :param pulumi.Input[str] space_id: ID (slug) of the space the worker pool is in """ + _WorkerPoolState._configure( + lambda key, value: pulumi.set(__self__, key, value), + config=config, + csr=csr, + description=description, + labels=labels, + name=name, + private_key=private_key, + space_id=space_id, + ) + @staticmethod + def _configure( + _setter: Callable[[Any, Any], None], + config: Optional[pulumi.Input[str]] = None, + csr: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + private_key: Optional[pulumi.Input[str]] = None, + space_id: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.ResourceOptions] = None, + **kwargs): + if private_key is None and 'privateKey' in kwargs: + private_key = kwargs['privateKey'] + if space_id is None and 'spaceId' in kwargs: + space_id = kwargs['spaceId'] + if config is not None: - pulumi.set(__self__, "config", config) + _setter("config", config) if csr is not None: - pulumi.set(__self__, "csr", csr) + _setter("csr", csr) if description is not None: - pulumi.set(__self__, "description", description) + _setter("description", description) if labels is not None: - pulumi.set(__self__, "labels", labels) + _setter("labels", labels) if name is not None: - pulumi.set(__self__, "name", name) + _setter("name", name) if private_key is not None: - pulumi.set(__self__, "private_key", private_key) + _setter("private_key", private_key) if space_id is not None: - pulumi.set(__self__, "space_id", space_id) + _setter("space_id", space_id) @property @pulumi.getter @@ -287,6 +335,10 @@ def __init__(__self__, resource_name: str, *args, **kwargs): if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: + kwargs = kwargs or {} + def _setter(key, value): + kwargs[key] = value + WorkerPoolArgs._configure(_setter, **kwargs) __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, @@ -306,13 +358,15 @@ def _internal_init(__self__, raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') __props__ = WorkerPoolArgs.__new__(WorkerPoolArgs) - __props__.__dict__["csr"] = csr + __props__.__dict__["csr"] = None if csr is None else pulumi.Output.secret(csr) __props__.__dict__["description"] = description __props__.__dict__["labels"] = labels __props__.__dict__["name"] = name __props__.__dict__["space_id"] = space_id __props__.__dict__["config"] = None __props__.__dict__["private_key"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["config", "csr", "privateKey"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) super(WorkerPool, __self__).__init__( 'spacelift:index/workerPool:WorkerPool', resource_name, diff --git a/sdk/python/setup.py b/sdk/python/setup.py index 7fc3e53..7421548 100644 --- a/sdk/python/setup.py +++ b/sdk/python/setup.py @@ -9,26 +9,6 @@ VERSION = "0.0.0" -PLUGIN_VERSION = "0.0.0" - -class InstallPluginCommand(install): - def run(self): - install.run(self) - try: - check_call(['pulumi', 'plugin', 'install', 'resource', 'spacelift', PLUGIN_VERSION, '--server', 'https://downloads.spacelift.io/pulumi-plugins']) - except OSError as error: - if error.errno == errno.ENOENT: - print(f""" - There was an error installing the spacelift resource provider plugin. - It looks like `pulumi` is not installed on your system. - Please visit https://pulumi.com/ to install the Pulumi CLI. - You may try manually installing the plugin by running - `pulumi plugin install resource spacelift {PLUGIN_VERSION}` - """) - else: - raise - - def readme(): try: with open('README.md', encoding='utf-8') as f: @@ -38,13 +18,11 @@ def readme(): setup(name='pulumi_spacelift', + python_requires='>=3.7', version=VERSION, description="A Pulumi package for creating and managing Spacelift resources.", long_description=readme(), long_description_content_type='text/markdown', - cmdclass={ - 'install': InstallPluginCommand, - }, keywords='pulumi spacelift category/cloud category/infrastructure', url='https://spacelift.io', project_urls={